Pup - the AI's own browser

@@ -2519,6 +2519,23 @@ async function recoverSessions() {         // Re-writing it here is idempotent and costs one in-process SetProp, and it means a machine         // carrying untagged windows heals on its next restart rather than staying unresolvable.         tagWindowSession(Number(sf._hwnd), sessionId).catch(() => {});+        // v2.0.366 (project-a5): RE-DERIVE THE EMULATION. Recovery restored the window but not its+        // emulation record, and Chrome keeps the CDP override because it lives in the browser. The+        // record defaulted to null, so every consumer confidently reported "not emulated" about a+        // window that was. Measure it back rather than guessing: a page whose innerWidth diverges+        // from its outerWidth is emulated, whatever pup happens to remember.+        (async () => {+          try {+            const t0 = (session.tabs || [])[0];+            if (!t0 || !t0.page) return;+            const m = await measureViewport(t0.page);+            if (m && m.emulated) {+              session._emulatedViewport = { width: m.innerWidth, height: m.innerHeight, deviceScaleFactor: m.devicePixelRatio, derived: true };+              session._lastOuterWidth = m.outerWidth;+              console.log(`[recovery] "${sessionId}" is still EMULATED at ${m.innerWidth}x${m.innerHeight} in a ${m.outerWidth}px window — record re-derived (it does not survive recovery on its own)`);+            }+          } catch (e) {}+        })();         // #80: tell this session it went through a restart, and how many tabs came back, so a         // thread that opened three and finds one knows WHY rather than concluding pup ate them.         const _tabsBack = (session.tabs || []).length;@@ -12045,6 +12062,31 @@ function bugReportInvite(isError) { // Resolve the session a response is ABOUT, from the caller's own addressing. pup's documented forms // are zero-id (resolve by ai-thread), {window:"..."} and the legacy {sessionId:"..."}, so all three // have to be honoured or a notice fires only for whichever form the author happened to test.+// GROUND TRUTH FOR EMULATION, measured rather than remembered (project-a5, 2026-08-28).+// pup used to answer "is this window emulated?" from its own record, and a RECOVERED window resets+// that record to null while Chrome keeps the CDP device-metrics override, because the override+// lives in the browser and not in pup. Every consumer then agreed the window was fine: the listings+// reported no override, the warning never fired, and reset's guard compared against nothing and+// passed vacuously with emulated:false while the page was demonstrably still 2200px wide in a+// 1688px window.+// outerWidth is the one number an override cannot fake, so the divergence IS the answer and needs+// no bookkeeping to survive a recovery. A real window's inner is a little smaller than its outer+// (borders, scrollbar); an emulated one is either far smaller or, in the cropping case, LARGER.+const EMULATION_SLACK = 60;+function looksEmulated(innerWidth, outerWidth) {+  if (!innerWidth || !outerWidth) return false;+  if (innerWidth > outerWidth + 2) return true;            // wider than the window: content cropped+  return (outerWidth - innerWidth) > EMULATION_SLACK;      // far narrower: dead space beside it+}+async function measureViewport(page) {+  try {+    const d = await page.evaluate(() => ({+      innerWidth: window.innerWidth, innerHeight: window.innerHeight,+      outerWidth: window.outerWidth, devicePixelRatio: window.devicePixelRatio,+    }));+    return { ...d, emulated: looksEmulated(d.innerWidth, d.outerWidth) };+  } catch (e) { return null; }+} function sessionForResponse(obj, argsIn) {   try {     const a = argsIn || {};@@ -15530,7 +15572,11 @@ const server = http.createServer(async (req, res) => {               try { tiM = await Promise.race([tM.page.title(), new Promise(r => setTimeout(() => r(null), 800))]); } catch (e) {}               tabsM.push({ tabId: tM.tabId, url: uM, title: tiM, active: tM.tabId === sM.activeTabId });             }-            wins.push({ window: sid, profile: sM.profileName, notYou: /^iso-/.test(sM.profileName || ''), lostBrowser: !!sM._lostBrowser, createdMinAgo: sM.createdAt ? Math.round((Date.now() - sM.createdAt) / 60000) : null, lastAgentUpdate: sM._lastAgentUpdate || null, tabs: tabsM });+            // emulatedViewport belongs HERE too (project-a5): pup_my_windows advertises itself as+            // "full state of everything your thread owns" and is the verb an AI reaches for first,+            // but it was the one listing that omitted the override entirely, so the first place you+            // look was the one place it could not tell you.+            wins.push({ window: sid, profile: sM.profileName, notYou: /^iso-/.test(sM.profileName || ''), lostBrowser: !!sM._lostBrowser, createdMinAgo: sM.createdAt ? Math.round((Date.now() - sM.createdAt) / 60000) : null, lastAgentUpdate: sM._lastAgentUpdate || null, emulatedViewport: sM._emulatedViewport || null, tabs: tabsM });           }           sendJSON(res, { success: true, output: JSON.stringify({ ok: true, 'ai-thread': who, windows: wins,             _hint: wins.length ? `These are ${who === _callerThread ? 'your' : `${who}'s`} windows. Target them with NO ids: any pup verb without sessionId resolves to your own thread's window (or address any thread via "ai-thread"). pup_screenshot {} to see it; pup_reload {} to refresh it; tab verbs take tabId.`@@ -17178,15 +17224,20 @@ const server = http.createServer(async (req, res) => {                 innerWidth: window.innerWidth, innerHeight: window.innerHeight,                 outerWidth: window.outerWidth, devicePixelRatio: window.devicePixelRatio,               }));-              // If it still reads as the width we just removed, the clear did NOT take. Say so.-              if (_prev && Math.abs(dims.innerWidth - _prev) <= 2) {+              // Verify by MEASUREMENT. The old check compared against the remembered override+              // width, so on a recovered window (record wiped, override live) there was nothing to+              // compare against and it passed vacuously. innerWidth vs outerWidth cannot be fooled+              // that way, and it also catches the case where the record was never there at all.+              const _stillEmulated = looksEmulated(dims.innerWidth, dims.outerWidth)+                || (_prev && Math.abs(dims.innerWidth - _prev) <= 2);+              if (_stillEmulated) {                 sendJSON(res, { success: false, error: `the viewport override did not clear: the page still reports innerWidth ${dims.innerWidth}, which is the override width`,                   errorCode: 'viewport_reset_failed',                   output: JSON.stringify({ ok: false, sessionId: resolvedId, tabId, emulated: true, ...dims }),                   _hint: `pup could not remove the emulation from this window. Close and reopen it (pup_close_window then pup_open_window) — a fresh window reports the real size. Do NOT trust in-page measurements from this window meanwhile: the page believes it is ${dims.innerWidth}px wide while the OS window is ${dims.outerWidth}px, so the user is seeing it cropped.` });                 return;               }-              sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId: resolvedId, tabId, reset: true, emulated: false, ...dims,+              sendJSON(res, { success: true, output: JSON.stringify({ ok: true, sessionId: resolvedId, tabId, reset: true, emulated: looksEmulated(dims.innerWidth, dims.outerWidth), ...dims,                 _hint: `Viewport override CLEARED — this window tracks the real OS window again (innerWidth now ${dims.innerWidth}, dpr ${dims.devicePixelRatio}). Resizing the window will reflow the page normally.` }) });             } catch (e) { sendJSON(res, { success: false, error: `clearing the viewport override failed: ${e.message}` }); }             return;