@usercase/mcp 0.2.2-next.1 → 0.2.2-next.3

package/agents/focus.md

@@ -17,6 +17,10 @@ Split how they arrive, about half and half:
 
 If the focus is only reachable when signed in, everyone is a member — this replaces "keep some as newcomers". Add newcomers only if the user asks for them (to see the sign-in wall). And cast the members to fit what the account has really done: if the user did not say a demo account already joined the room or saved the item, do not write people who are "already in the room" or "checking their saved list" — write people who join, save or start there on this visit.
 
+Write the focus into the goal itself, including the step it takes to get in: if reading or writing in it needs joining, saving or signing up first, the goal says the person means to do that if it looks worthwhile ("see what the holders are saying, and join and say hello if it looks lively") — not only "look whether there are posts", which ends at the first Join button. Mention the focused action itself (e.g. the chat), not just the area around it.
+
+A second thing on their mind stays inside the focus or leads into it (reading the chat and then the room's notices; a news card that sends them looking for the room) — never another part of the site (the calendar, the price list). Here that would be an easy way out of the focus, and the run would lose the visit.
+
 Do not add people who have nothing to do with the focus. In later rounds, cast new people for the same focus.
 
 **Step 4 — unchanged.** The visitors are never told about the focus.

package/mcp/hub.js

@@ -399,7 +399,18 @@ class Hub {
     const look = await v.look();
     if (look.ended) return "This visit has ended.";
     if (look.card) return renderCard(look.card);
-    const lines = [renderScreen(look)];
+    const lines = [];
+    // 굴리지 않았는데 맨 위로 돌아갔다(창이 닫히며 주소가 바뀐 사이트). 사람은 화면이 튀는 걸 본다(10/21 실험실 q3)
+    // 다른 페이지로 간 것은 원래 맨 위에서 시작한다 — 같은 페이지(? 뒤만 바뀐 것 포함)일 때만
+    const y = look.view.scrollY;
+    const at = look.view.path.split("?")[0];
+    // 창이 뜨거나 닫히며 위치 기준(페이지 ↔ 창)이 바뀐 것은 튄 게 아니다(10/21 실험실 r3)
+    const cover = !!(look.view.cover || look.view.inPanel);
+    if (rec.lastY > 300 && y < 40 && at === rec.lastAt && cover === rec.lastCover && !/^scroll/.test(rec.lastAction || "")) lines.push("(The page jumped back to the top.)", "");
+    rec.lastY = y;
+    rec.lastAt = at;
+    rec.lastCover = cover;
+    lines.push(renderScreen(look));
     // 인내심이 다 됐다는 단정이 아니라 조건이다. "볼 만큼 봤다" 고 하면 방문자가 그 자리에서 나갔다 — 진전이 있으면 이어 간다(10/14)
     if (v.patienceSpent) lines.push("", "(Your patience is running low. Unless what is in front of you is getting you closer to what you came for, this is about where you would give up.)");
     return lines.join("\n");
@@ -417,6 +428,7 @@ class Hub {
   async act(id, decision) {
     const rec = this.get(id);
     const v = rec.visit;
+    rec.lastAction = decision.action;
     const r = await v.act(decision);
     if (r.interrupted) return ["Before you could do that, a survey card appeared.", "", await this.screen(rec)].join("\n");
     const said = [];
@@ -439,7 +451,10 @@ class Hub {
       const sum = await this.finish(rec);
       return [...said, "You left the site. This visit is over.", "", sum].join("\n");
     }
-    return [...said, ...(said.length ? [""] : []), await this.screen(rec)].join("\n");
+    const shown = await this.screen(rec);
+    // 하는 사이에 카드가 떴다. 손가락이 카드에 먼저 닿았을 수 있다 — 말 없이 카드만 주면 클릭이 왜 안 됐는지 모른다(10/21 실험실 t3)
+    if (v.pending && !/^(read|leave)$/.test(decision.action)) said.push("A survey card popped up just as you did that — once you have dealt with it, check whether what you did went through.");
+    return [...said, ...(said.length ? [""] : []), shown].join("\n");
   }
 
   /** 카드에 답하거나 닫는다 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usercase/mcp",
-  "version": "0.2.2-next.1",
+  "version": "0.2.2-next.3",
   "description": "Virtual users that browse your website and tell you what they thought — an MCP server for Claude Code",
   "license": "UNLICENSED",
   "homepage": "https://usercase.io",

package/src/browser/hand.js

@@ -92,7 +92,14 @@ async function aimAt(page, state, el) {
     const py = Math.min(Math.max(y, box.y + 2), box.y + box.height - 2);
     if ((await at(px, py)) === "대상") return { x: px, y: py, missed: false };
   }
-  return (await at(cx, cy)) === "대상" ? { x: cx, y: cy, missed: false } : null;
+  if ((await at(cx, cy)) === "대상") return { x: cx, y: cy, missed: false };
+  // 가운데만 가렸으면 사람은 보이는 쪽을 누른다 — 화면에 붙은 창의 Join 버튼 아래쪽이 아래 메뉴에 깔려
+  // 굴려도 안 비켜서 "Watchlist 가 덮었다" 가 됐다(10/21 실험실 q2). 가운데에서 가까운 점부터 본다
+  const pts = [];
+  for (const fy of [0.2, 0.35, 0.5, 0.65, 0.8]) for (const fx of [0.5, 0.3, 0.7, 0.15, 0.85]) pts.push([box.x + box.width * fx, box.y + box.height * fy]);
+  pts.sort((a, b) => Math.hypot(a[0] - cx, a[1] - cy) - Math.hypot(b[0] - cx, b[1] - cy));
+  for (const [px, py] of pts) if ((await at(px, py)) === "대상") return { x: px, y: py, missed: false };
+  return null;
 }
 
 /**
@@ -215,6 +222,7 @@ async function swipeIntoView(page, state, el, vw) {
  * @returns { missed: boolean }  missed 면 빈 곳을 눌러 아무 일도 안 일어난 것이다
  */
 async function clickLikePerson(page, state, el) {
+  const startY = await page.evaluate(() => scrollY).catch(() => null);
   // 위아래로만 굴린다. 사람은 휴대폰에서 화면을 옆으로 끌어 숨은 버튼을 찾지 않는다 — 옆으로 굴리면 화면 밖 것을 끌어와 눌렀다(10/15)
   await el
     .evaluate((n) => {
@@ -226,10 +234,16 @@ async function clickLikePerson(page, state, el) {
   if (!aim) {
     // 화면 끝에 걸쳐 고정 막대(위 머리줄·아래 메뉴)에 가린 것은 사람이 조금 더 굴려서 누른다.
     // 이걸 안 하고 "덮였다" 고 하면 모바일 아래 메뉴 밑 항목이 안 눌린다(10/14 bluetags p28, 0.1.12)
+    // 창 안(스크롤되는 칸)의 것이면 그 칸을 굴린다 — 페이지만 굴려서는 모바일 정보 창 맨 아래 Join 이
+    // 아래 메뉴 밑에서 안 나왔다(10/21 실험실 y2). scrollIntoView 는 감싼 칸들을 모두 굴린다
     await el
       .evaluate((n) => {
-        const r = n.getBoundingClientRect();
-        window.scrollBy(0, r.top + r.height / 2 - innerHeight / 2);
+        const before = n.getBoundingClientRect().top;
+        n.scrollIntoView({ block: "center", inline: "nearest", behavior: "instant" });
+        if (Math.abs(n.getBoundingClientRect().top - before) < 1) {
+          const r = n.getBoundingClientRect();
+          window.scrollBy(0, r.top + r.height / 2 - innerHeight / 2);
+        }
       })
       .catch(() => {});
     await sleep(rand(150, 350));
@@ -256,6 +270,8 @@ async function clickLikePerson(page, state, el) {
       return { missed: false, closedOverlay: gone };
     }
     if (cover) {
+      // 못 누른 채 화면만 굴러가 있으면 "안 됐다" 는데 화면이 바뀐다(10/21 실험실 q2) — 사람은 굴리지 않고 덮인 걸 본다
+      if (startY !== null) await page.evaluate((y) => window.scrollTo({ top: y, behavior: "instant" }), startY).catch(() => {});
       const e = new Error(cover.say);
       e.human = cover.say;
       throw e;
@@ -339,14 +355,78 @@ async function scrollLikePerson(page, state, dir = 1) {
   const total = (300 + Math.random() * 700) * dir;
   const chunks = 2 + Math.round(Math.random() * 2);
   const y0 = await page.evaluate(() => scrollY).catch(() => null);
+  // 휴대폰에서는 화면 가운데를 엄지로 민다. 커서가 처음 자리(0,0)에 있으면 휠이 그 자리의 것을 굴린다 —
+  // 화면을 덮은 정보 창 대신 그 뒤 페이지가 굴러, 창 맨 아래 Join 이 끝내 아래 메뉴 밑에 있었다(10/21 실험실 r1).
+  // 데스크톱도 커서가 아직 한 번도 안 움직였으면 본문 쪽으로 옮겨 굴린다
+  const touch = await page.evaluate(() => matchMedia("(pointer: coarse)").matches).catch(() => false);
+  const vp0 = page.viewportSize() || { width: 1200, height: 800 };
+  // 흐린 막 위에 창이 떠 있으면 사람은 그 창 위에서 굴린다 — 주소로 바로 열린 데스크톱 정보 창은 뒤 페이지가
+  // 안 잠겨 휠이 뒤 목록을 굴렸고, 창 맨 아래 Join 을 끝내 못 봤다(10/21 실험실 u4)
+  const panel = await page
+    .evaluate(() => {
+      const VW = document.documentElement.clientWidth || innerWidth;
+      const fixedCtx = (n) => {
+        for (let p = n; p && p !== document.body; p = p.parentElement) if (getComputedStyle(p).position === "fixed") return true;
+        return false;
+      };
+      // 화면에 붙은 큰 판 — 흐린 막(데스크톱 정보 창 뒤)이든 화면을 덮은 불투명한 창(모바일 정보 창)이든
+      let overlay = false;
+      for (const n of document.body.querySelectorAll("*")) {
+        const m = getComputedStyle(n).backgroundColor.match(/[\d.]+/g);
+        const a = !m ? 0 : m.length > 3 ? parseFloat(m[3]) : 1;
+        if (!a) continue;
+        const r = n.getBoundingClientRect();
+        if ((a < 0.9 ? r.width >= VW * 0.5 : r.width >= VW * 0.9) && r.height >= innerHeight * 0.6 && fixedCtx(n)) {
+          overlay = true;
+          break;
+        }
+      }
+      if (!overlay) return null;
+      let best = null;
+      let area = 0;
+      for (const n of document.body.querySelectorAll("*")) {
+        if (n.scrollHeight <= n.clientHeight + 2 || n.clientHeight < 100 || !/auto|scroll/.test(getComputedStyle(n).overflowY) || !fixedCtx(n)) continue;
+        const r = n.getBoundingClientRect();
+        const cx = r.left + r.width / 2;
+        const cy = Math.min(r.top + r.height / 2, innerHeight - 5);
+        const h = document.elementFromPoint(cx, cy);
+        if (!h || !(n === h || n.contains(h))) continue; // 위에 떠 있는 칸만
+        const a = r.width * r.height;
+        if (a > area) (area = a), (best = { x: cx, y: cy });
+      }
+      return best;
+    })
+    .catch(() => null);
+  if (panel) await moveTo(page, state, panel.x + rand(-30, 30), panel.y + rand(-40, 40));
+  else if (touch || !state.mouse || (state.mouse.x < 5 && state.mouse.y < 5)) {
+    await moveTo(page, state, vp0.width * rand(0.4, 0.6), vp0.height * rand(0.4, 0.6));
+  }
   for (let i = 0; i < chunks; i++) {
     await page.mouse.wheel(0, total / chunks);
     await sleep(rand(80, 260));
     // 커서가 메뉴·고정 막대 위에 있으면 휠이 페이지를 안 굴린다. 사람은 커서를 본문 쪽으로 옮기고 다시 굴린다
     // (10/13: 약관 링크를 누른 뒤 세 번 굴려도 0px)
     if (i === 0 && y0 !== null && (await page.evaluate(() => scrollY).catch(() => null)) === y0) {
+      // 페이지가 잠겼고 화면 한쪽 칸만 굴러가면(데스크톱 정보 창) 사람은 그 칸 위로 커서를 옮긴다(10/21 실험실 r4)
+      const pane = await page
+        .evaluate(() => {
+          // 페이지가 그냥 끝에 닿은 것이면 안쪽 칸을 찾지 않는다
+          if (document.documentElement.scrollHeight > innerHeight + 2 && getComputedStyle(document.body).overflowY !== "hidden") return null;
+          let best = null;
+          let area = 0;
+          for (const n of document.body.querySelectorAll("*")) {
+            if (n.scrollHeight <= n.clientHeight + 2 || n.clientHeight < 100 || n.scrollTop + n.clientHeight >= n.scrollHeight - 2) continue;
+            if (!/auto|scroll/.test(getComputedStyle(n).overflowY)) continue;
+            const r = n.getBoundingClientRect();
+            const a = Math.max(0, Math.min(r.right, innerWidth) - Math.max(r.left, 0)) * Math.max(0, Math.min(r.bottom, innerHeight) - Math.max(r.top, 0));
+            if (a > area) (area = a), (best = { x: r.left + r.width / 2, y: r.top + r.height / 2 });
+          }
+          return best;
+        })
+        .catch(() => null);
       const vp = page.viewportSize() || { width: 1200, height: 800 };
-      await moveTo(page, state, vp.width * rand(0.45, 0.6), vp.height * rand(0.45, 0.65));
+      if (pane) await moveTo(page, state, pane.x + rand(-30, 30), pane.y + rand(-40, 40));
+      else await moveTo(page, state, vp.width * rand(0.45, 0.6), vp.height * rand(0.45, 0.65));
       await page.mouse.wheel(0, total / chunks);
       await sleep(rand(80, 260));
     }
@@ -357,7 +437,9 @@ async function scrollLikePerson(page, state, dir = 1) {
   const after = await pos();
   const moved = after && y0 !== null ? after.y - y0 : 0;
   const atEnd = after && (dir > 0 ? after.y >= after.max - 2 : after.y <= 2);
-  if (Math.sign(moved) === Math.sign(dir) && Math.abs(moved) > 120 && !atEnd && Math.random() < 0.25) {
+  // 창 안을 굴렸으면 되돌리지 않는다 — 뒤 페이지가 움직인 만큼 되돌리다 창 안이 맨 위로 돌아가,
+  // 창 맨 아래 Join 이 아래 메뉴 밑에 다시 갇혔다(10/21 실험실 x4)
+  if (!panel && Math.sign(moved) === Math.sign(dir) && Math.abs(moved) > 120 && !atEnd && Math.random() < 0.25) {
     await sleep(rand(150, 500));
     await page.mouse.wheel(0, -moved * (0.15 + Math.random() * 0.2));
   }

package/src/browser/page.js

@@ -58,6 +58,15 @@ async function listControls(page, max = 60) {
         }
         return op <= 0.45;
       };
+      /**
+       * 화면 끝에 몇 px 만 걸친 것은 사람 눈에 아직 없다 — 창 맨 아래 Join 이 4px 걸쳐 "화면 안" 으로 나오고
+       * 화면 글에는 없어 서로 어긋났다(10/21 실험실 r2·s1). 반 넘게(긴 것은 16px 넘게) 보여야 화면 안이다
+       */
+      const whereOf = (r) => {
+        const shown = Math.min(r.bottom, innerHeight) - Math.max(r.top, 0);
+        if (shown >= Math.min(r.height / 2, 16) && r.right > 0 && r.left < VW) return "in view";
+        return (r.top + r.bottom) / 2 >= innerHeight / 2 ? "below" : "above";
+      };
       const nameOf = (el) =>
         (el.getAttribute("aria-label") || el.getAttribute("title") || el.innerText || el.value || el.getAttribute("placeholder") || "")
           .replace(/\s+/g, " ")
@@ -78,8 +87,8 @@ async function listControls(page, max = 60) {
         const key = tag + "|" + label + "|" + (href || `@${Math.round(r.left)},${Math.round(r.top + scrollY)}`);
         if (seen.has(key)) continue;
         seen.add(key);
-        const inView = r.bottom > 0 && r.top < innerHeight && r.right > 0 && r.left < VW;
-        const where = inView ? "in view" : r.top >= innerHeight ? "below" : "above";
+        const where = whereOf(r);
+        const inView = where === "in view";
         cand.push({ el, tag, label, href: href ? href.split(/[?#]/)[0] : "", where, rank: inView ? 0 : where === "below" ? 1 : 2, dim: dimmed(el), edge: (r.left + r.right) / 2 > VW - 1 || (r.left + r.right) / 2 < 1 });
         // 성능용 안전 상한. 이건 사람에게 보여줄 예산이 아니다
         if (cand.length >= 800) break;
@@ -142,14 +151,17 @@ async function listControls(page, max = 60) {
         const r = el.getBoundingClientRect();
         // 작은 크기는 글자 없는 것에만 따진다. 날짜 "1" 은 폭이 5px 이라 빠졌다(10/14 실험실 달력)
         if (text ? r.width < 2 || r.height < 6 : r.width < 8 || r.height < 8) continue;
+        // 글자 없이 화면 반을 덮는 것은 아이콘이 아니라 창 뒤의 막이다 — "(icon 0,0)" 으로 나와 방문자가 뭔지 몰랐다(10/21 실험실 q5).
+        // 막 뒤의 것을 누르면 손이 막을 누른다
+        if (!text && r.width * r.height > VW * innerHeight * 0.25) continue;
         const hint = text ? null : iconHint(el);
         const label = text || (hint ? `(icon: ${hint})` : `(icon ${Math.round(r.left)},${Math.round(r.top)})`);
         // 같은 말인 칩이 여럿인 UI 가 흔하다(태그 목록). 자리까지 봐야 서로 다른 조작으로 남는다
         const key = `pointer|${label}|${Math.round(r.left)},${Math.round(r.top + scrollY)}`;
         if (seen.has(key)) continue;
         seen.add(key);
-        const inView = r.bottom > 0 && r.top < innerHeight && r.right > 0 && r.left < VW;
-        const where = inView ? "in view" : r.top >= innerHeight ? "below" : "above";
+        const where = whereOf(r);
+        const inView = where === "in view";
         cand.push({ el, tag: el.tagName.toLowerCase(), label, href: "", where, rank: inView ? 0 : where === "below" ? 1 : 2, size: `${Math.round(r.width)}x${Math.round(r.height)}`, dim: dimmed(el), edge: (r.left + r.right) / 2 > VW - 1 || (r.left + r.right) / 2 < 1 });
       }
 
@@ -160,6 +172,83 @@ async function listControls(page, max = 60) {
        * 지금 화면에 보이는 것부터 남기고, 같은 순위 안에서는 문서 순서를 지킨다(sort 는 안정 정렬).
        * 2026-09-21 여기어때에서 드러났다. 블루태그스 Week/Month 토글도 같은 결의 문제였다.
        */
+      /**
+       * 화면을 통째로 덮은 층(모바일의 전체 화면 정보 창) 밑에 깔린 것은 사람 눈에 없다. 목록에 넣으면 방문자가
+       * 밑의 카드를 누르고 "덮였다" 만 세 번 듣고 나갔다(10/21 bluetags p1937, /community?info= 모바일).
+       * 고정 머리줄·아래 메뉴처럼 좁은 막대에 가린 것은 남긴다 — 손이 굴려서 누른다
+       */
+      const buried = (el) => {
+        const r = el.getBoundingClientRect();
+        const x = Math.min(Math.max((r.left + r.right) / 2, 1), VW - 1);
+        const y = Math.min(Math.max((r.top + r.bottom) / 2, 1), innerHeight - 1);
+        // 위에서부터 겹친 것을 다 본다 — 맨 위가 다른 작은 것(사이트의 설문 창)이어도 그 밑에 덮은 층이 있다
+        for (const h of document.elementsFromPoint(x, y)) {
+          if (h === el || el.contains(h) || h.contains(el)) return false;
+          if (h.closest(ownSel)) continue;
+          // 맞은 것에서 올라가며 처음 칠이 있는 것. 반투명한 뒤판(데스크톱 정보 창 옆의 흐린 막)은 비쳐 보이고
+          // 누르면 창이 닫힌다 — 남긴다. 칠 없는 것은 투명하니 그 밑을 본다
+          for (let n = h; n && n !== document.body && !n.contains(el); n = n.parentElement) {
+            const m = getComputedStyle(n).backgroundColor.match(/[\d.]+/g);
+            const alpha = !m ? 0 : m.length > 3 ? parseFloat(m[3]) : 1;
+            if (!alpha) continue;
+            const lr = n.getBoundingClientRect();
+            const big = Math.min(lr.right, VW) - Math.max(lr.left, 0) >= VW * 0.9 && Math.min(lr.bottom, innerHeight) - Math.max(lr.top, 0) >= innerHeight * 0.6;
+            // 반투명한 큰 막 밑 = 열린 창 뒤에 흐리게 보이는 것. 사람은 창이 떠 있는 줄 안다 — 방문자도 알아야
+            // 뒤의 카드를 눌러 창만 닫히는 걸 이해한다(10/21 실험실 q3)
+            if (big && alpha < 0.9) return "dim";
+            if (big) {
+              covers.add(n);
+              return "under";
+            }
+            break; // 작은 것(사이트의 설문 창, 고정 막대) — 그 밑을 본다
+          }
+        }
+        return false;
+      };
+      const covers = new Set();
+      for (let k = cand.length - 1; k >= 0; k--) {
+        if (cand[k].where !== "in view") continue;
+        const b = buried(cand[k].el);
+        if (b === "under") cand.splice(k, 1);
+        else if (b === "dim") cand[k].behind = true;
+      }
+      // 덮은 층이 화면에 붙어 있으면(fixed) 굴려도 그대로 덮여 있다 — 그 밖의 위·아래 것도 안 보인다.
+      // 남기면 "위에 있다" 고 나와 방문자가 올려 보고 누르다 덮였다를 듣는다(10/21 실험실 q2)
+      const fixedCovers = [...covers].filter((n) => {
+        for (let p = n; p && p !== document.body; p = p.parentElement) if (getComputedStyle(p).position === "fixed") return true;
+        return false;
+      });
+      if (fixedCovers.length) for (let k = cand.length - 1; k >= 0; k--) if (cand[k].where !== "in view" && !fixedCovers.some((n) => n.contains(cand[k].el))) cand.splice(k, 1);
+      // 화면을 덮은 창이 있으면 굴리는 건 그 창이다. 뒤 페이지의 위치를 말하면 "아래에 더 있다" 는데 굴려도 화면이 그대로였다(10/21 실험실 r1)
+      // 페이지가 잠겨 있으면(창이 뜨며 사이트가 막음) 화면에서 굴러가는 가장 큰 칸 — 데스크톱 정보 창 안쪽(10/21 실험실 r4)
+      // 흐린 막 위에 창이 떠 있으면 사람은 그 창을 굴린다 — 주소로 바로 열린 창은 뒤 페이지가 안 잠겨
+      // 위치·"아래에 더" 가 뒤 페이지 기준이라 창 맨 아래 Join 을 끝내 못 봤다(10/21 실험실 u4)
+      const dimOpen = cand.some((c) => c.behind);
+      const pageLocked = dimOpen || document.documentElement.scrollHeight <= innerHeight + 2 || getComputedStyle(document.body).overflowY === "hidden";
+      let roll = { y: scrollY, height: document.documentElement.scrollHeight, viewport: innerHeight };
+      // 굴리는 칸이 페이지가 아니면 "아래에 더 있다" 도 그 칸 안의 것만 센다 — 잠긴 페이지 뒤 목록을 세면 끝에 닿아도 "더 있다" 였다
+      let pane = null;
+      if (fixedCovers.length || pageLocked) {
+        roll = { y: 0, height: innerHeight, viewport: innerHeight };
+        pane = fixedCovers[0] || null;
+        let best = 0;
+        for (const n of fixedCovers.length ? [fixedCovers[0], ...fixedCovers[0].querySelectorAll("*")] : document.body.querySelectorAll("*")) {
+          if (n.scrollHeight <= n.clientHeight + 2 || n.clientHeight < 100) continue;
+          if (!/auto|scroll/.test(getComputedStyle(n).overflowY)) continue;
+          // 창이 떠 있으면 창 쪽(흐리지 않은 것을 품은 칸)만
+          // 뒤 목록까지 품은 바깥 칸(페이지 틀)은 창이 아니다 — 그걸 굴리면 뒤 목록이 굴렀다
+          if (dimOpen && (!cand.some((c) => !c.behind && c.where === "in view" && n.contains(c.el)) || cand.some((c) => c.behind && n.contains(c.el)))) continue;
+          const r = n.getBoundingClientRect();
+          const area = Math.max(0, Math.min(r.right, VW) - Math.max(r.left, 0)) * Math.max(0, Math.min(r.bottom, innerHeight) - Math.max(r.top, 0));
+          if (area > best) {
+            best = area;
+            pane = n;
+            roll = { y: n.scrollTop, height: n.scrollHeight, viewport: n.clientHeight };
+          }
+        }
+      }
+      // 창이 떠 있으면 창 밖의 위·아래 것은 굴려도 안 온다 — 뒤 목록의 필터가 "위에 있다" 로 남았다(10/21 실험실 u1)
+      if (pageLocked || fixedCovers.length) for (let k = cand.length - 1; k >= 0; k--) if (cand[k].where !== "in view" && !(pane && pane.contains(cand[k].el))) cand.splice(k, 1);
       cand.sort((a, b) => a.rank - b.rank);
       /**
        * **화면 아래는 보여주지 않는다.** 사람은 내려 봐야 거기 뭐가 있는지 안다.
@@ -204,17 +293,23 @@ async function listControls(page, max = 60) {
       const picked = pool.slice(0, max);
       const groups = {};
       for (const c of picked) (groups[c.label] = groups[c.label] || []).push(c);
-      const nearAt = (c, d) => {
+      const nearAt = (c, d, g) => {
         let p = c.el.parentElement;
         for (let k = 0; k < d && p && p !== document.body; k++) p = p.parentElement;
-        return p ? (p.innerText || "").replace(/\s+/g, " ").replace(c.label, "").trim().slice(0, 40) : "";
+        if (!p) return "";
+        // 같은 이름의 다른 항목까지 감싼 덩어리의 글자는 그 항목의 곁이 아니다 — 맨 아래 "Bluetags" 에
+        // 페이지 전체의 첫 글(맨 위 카드)이 붙었다(10/21 실험실 q4·s4)
+        if (g.some((o) => o !== c && p.contains(o.el))) return "";
+        // 제 이름은 낱말째로만 뺀다 — 이름이 "0" 인 항목에서 날짜 "20" 의 0 이 빠져 "Oct 2" 가 됐다(10/21 실험실 w5)
+        const own = new RegExp(`(^|\\s)${c.label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?=\\s|$)`);
+        return (p.innerText || "").replace(/\s+/g, " ").replace(own, "$1").replace(/\s+/g, " ").trim().slice(0, 40);
       };
       for (const [label, g] of Object.entries(groups)) {
         if (g.length < 2) continue;
         // 묶음 안에서 서로 다르게 읽히는 가장 가까운 층을 고른다. 없으면 순서로 가른다
         let hints = null;
         for (let d = 0; d < 6 && !hints; d++) {
-          const h = g.map((c) => nearAt(c, d));
+          const h = g.map((c) => nearAt(c, d, g));
           if (h.every((x) => x.length >= 2) && new Set(h).size === h.length) hints = h;
         }
         g.forEach((c, k) => (c.label = hints ? `${label} (${hints[k]})` : `${label} (${k + 1} of ${g.length})`));
@@ -223,7 +318,7 @@ async function listControls(page, max = 60) {
       const out = picked.map((c, i) => {
         els.push(c.el);
         // 반 넘게 화면 옆으로 나간 것. 누르면 손이 "잘렸다" 고 한다 — 목록도 같은 말을 해야 한다(10/15 실험실 x87: 공유 막대가 화면을 넓혀 아래 메뉴가 밀렸다)
-        return { i, tag: c.tag, label: c.label, href: c.href, where: c.where, ...(c.dim ? { dim: true } : {}), ...(c.edge ? { edge: true } : {}) };
+        return { i, tag: c.tag, label: c.label, href: c.href, where: c.where, ...(c.dim ? { dim: true } : {}), ...(c.edge ? { edge: true } : {}), ...(c.behind ? { behind: true } : {}) };
       });
       Object.defineProperty(window, "__ebMcpEls", { value: els, configurable: true, enumerable: false, writable: true });
       return {
@@ -238,12 +333,17 @@ async function listControls(page, max = 60) {
         /** 그중 이름 없는 작은 아이콘 수 */
         droppedIcons: iconsLeft,
         /** 화면 아래에 더 있는 조작 수. 무엇인지는 말하지 않는다 */
-        below,
+        below: pane ? cand.filter((c) => c.where === "below" && pane.contains(c.el)).length : below,
         path: location.pathname + location.search,
         title: (document.title || "").slice(0, 120),
-        scrollY: Math.round(scrollY),
-        height: document.documentElement.scrollHeight,
-        viewport: innerHeight,
+        /** 화면을 덮은 창이 떠 있다 — 위치는 그 창 기준이다 */
+        cover: fixedCovers.length > 0,
+        /** 굴리는 것이 페이지가 아니라 떠 있는 창 안쪽이다 */
+        // 본문이 안쪽 칸에서 굴러가는 앱형 사이트도 페이지가 잠겨 보인다 — 창이 실제로 떠 있을 때만
+        inPanel: !!pane && (fixedCovers.length > 0 || cand.some((c) => c.behind)),
+        scrollY: Math.round(roll.y),
+        height: roll.height,
+        viewport: roll.viewport,
       };
     },
     { ownSel: OWN_SEL, max },
@@ -272,8 +372,38 @@ async function visibleText(page, max = 2500) {
         }
         return false;
       };
+      /**
+       * listControls 의 buried 와 같다 — 화면을 통째로 덮은 불투명한 층(모바일 전체 화면 정보 창) 밑의 글자는 안 보인다.
+       * 남기면 창 글자와 밑의 목록이 한 덩어리로 섞여 새 페이지인지 창인지 모른다(10/21 실험실 q4)
+       */
+      // false | "under"(안 보임) | "dim"(열린 창 뒤에 흐리게 보임)
+      const buriedCache = new Map();
+      const buried = (el, r) => {
+        if (buriedCache.has(el)) return buriedCache.get(el);
+        let res = false;
+        const x = Math.min(Math.max((r.left + r.right) / 2, 1), VW - 1);
+        const y = Math.min(Math.max((r.top + r.bottom) / 2, 1), innerHeight - 1);
+        outer: for (const h of document.elementsFromPoint(x, y)) {
+          if (h === el || el.contains(h) || h.contains(el)) break;
+          if (h.closest(ownSel)) continue;
+          for (let n = h; n && n !== document.body && !n.contains(el); n = n.parentElement) {
+            const m = getComputedStyle(n).backgroundColor.match(/[\d.]+/g);
+            const alpha = !m ? 0 : m.length > 3 ? parseFloat(m[3]) : 1;
+            if (!alpha) continue;
+            const lr = n.getBoundingClientRect();
+            if (Math.min(lr.right, VW) - Math.max(lr.left, 0) >= VW * 0.9 && Math.min(lr.bottom, innerHeight) - Math.max(lr.top, 0) >= innerHeight * 0.6) {
+              res = alpha >= 0.9 ? "under" : "dim";
+              break outer;
+            }
+            break;
+          }
+        }
+        buriedCache.set(el, res);
+        return res;
+      };
       const walker = document.createTreeWalker(document.body || document.documentElement, NodeFilter.SHOW_TEXT);
       const range = document.createRange();
+      const behind = [];
       let n = 0;
       for (let node = walker.nextNode(); node; node = walker.nextNode()) {
         if (++n > 20000) break;
@@ -288,15 +418,30 @@ async function visibleText(page, max = 2500) {
         const st = getComputedStyle(el);
         if (st.visibility === "hidden" || st.opacity === "0") continue;
         if (clippedX(el, r)) continue;
+        const b = buried(el, r);
+        if (b === "under") continue;
+        // 열린 창 뒤에 흐리게 비치는 글은 따로 모은다 — 섞으면 창이 어디서 끝나는지 모른다(10/21 실험실 q3·r4·s1·t1)
+        if (b === "dim") {
+          behind.push(txt);
+          continue;
+        }
         if (lastTop !== null && Math.abs(r.top - lastTop) > 4) out.push("\n");
         else if (out.length) out.push(" ");
         out.push(txt);
         lastTop = r.top;
       }
+      // 뒤의 흐린 글은 짧게 — 길면 글자 한도를 먹어 창 쪽 글이 단어 중간에 잘렸다(10/21 실험실 u1)
+      if (behind.length) {
+        const b = behind.join(" · ");
+        out.push("\n\n[Behind the open panel, dimmed:]\n", b.length > 500 ? b.slice(0, b.lastIndexOf(" ", 500)) + " …" : b);
+      }
       return out.join("");
     }, OWN_SEL)
     .catch(() => "");
-  return t.replace(/[ \t]+/g, " ").replace(/\n{2,}/g, "\n").trim().slice(0, max);
+  const s = t.replace(/[ \t]+/g, " ").replace(/\n{2,}/g, "\n").trim();
+  if (s.length <= max) return s;
+  // 넘치면 낱말 사이에서 자르고 잘렸다고 적는다 — "disap" 처럼 끊기면 화면이 그렇게 생긴 줄 안다(10/21 실험실 u1)
+  return s.slice(0, Math.max(s.lastIndexOf(" ", max), s.lastIndexOf("\n", max), max - 40)) + " … (more text on screen not shown)";
 }
 
 /** 번호로 그 요소를 집는다. 화면이 바뀌었으면 null */

package/src/run/visit.js

@@ -181,7 +181,9 @@ function renderScreen(look) {
     "```",
     "",
     "## Things you can use (number · what it says · where)",
-    ...view.items.map((it) => `[${it.i}] ${it.label || "(no text)"}${it.href ? ` → ${it.href}` : ""}${it.dim ? " · looks greyed out" : ""}${it.edge ? " · cut off at the edge of the screen" : ""} · ${it.where}`),
+    ...view.items.map((it) => `[${it.i}] ${it.label || "(no text)"}${it.href ? ` → ${it.href}` : ""}${it.dim ? " · looks greyed out" : ""}${it.edge ? " · cut off at the edge of the screen" : ""}${it.behind ? " · dimmed, behind the open panel" : ""} · ${it.where}`),
+    // 떠 있는 창 뒤가 흐리게 비치는 화면. 글로 옮기면 창과 뒤 페이지가 한 덩어리로 섞인다(10/21 실험실 q3)
+    ...(view.items.some((it) => it.behind) ? ["(A panel is open on top of the page; the page behind it is dimmed.)"] : []),
     // 화면 안에 있는데 목록에 못 넣은 것. "아래에 더 있다" 고 하면 내려 봐도 못 찾는다
     // 화면 안에서 빠진 것과 지나온 위쪽에서 빠진 것을 따로 말한다 — 한 숫자로 말하면 "화면에 너무 많다" 가 거짓이 된다
     ...(view.droppedInView
@@ -192,11 +194,18 @@ function renderScreen(look) {
         ? [`(${view.dropped} more things further up the page are not listed — scroll up to use them.)`]
         : []),
     // 아래에 더 있다는 것만. 무엇인지는 내려 봐야 안다
-    ...(view.below
-      ? [`(The page goes on below. Scroll down to see what is there.)`]
+    // 굴릴 데가 없는데 "아래에 더 있다" 고 하면 모순이다 — 창이 뜨며 사이트가 페이지 스크롤을 잠근 때(10/21 실험실 r2·r4)
+    ...(view.height - view.viewport <= 2
+      ? ["(Nothing on this screen scrolls right now.)"]
+      // 끝까지 내려왔으면 "아래에 더" 라고 하지 않는다 — 화면 밖 아래에 걸린 것이 있어도 굴려서 못 온다(10/21 실험실 t3)
+      : view.below && view.height - view.viewport - view.scrollY > 2
+      ? [view.inPanel ? "(The open panel goes on below. Scroll down to see the rest of it.)" : `(The page goes on below. Scroll down to see what is there.)`]
+      : view.height - view.viewport - view.scrollY > Math.max(40, view.viewport * 0.25)
+        ? [view.inPanel ? "(There is more of the open panel below.)" : "(There is more of the page below.)"]
+      // 조금 남은 것(화면 맨 아래 버튼의 나머지, 여백)을 "더 있다" 고 하면 굴려도 새것이 없었다(10/21 실험실 s2·u2·w2)
       : view.height - view.viewport - view.scrollY > 40
-        ? ["(There is more of the page below.)"]
-        : ["(This is the bottom of the page.)"]),
+        ? ["(Nearly the bottom — only a little more below.)"]
+        : [view.inPanel ? "(This is the bottom of the open panel.)" : "(This is the bottom of the page.)"]),
   ].join("\n");
 }