Pup - the AI's own browser

@@ -12055,6 +12055,34 @@ function sessionForResponse(obj, argsIn) {     return null;   } catch (e) { return null; } }+// Notices that describe THIS session's state, delivered on the verbs that would otherwise report a+// confident wrong answer. Deliberately outside the bug-invite path: these are not bug reports.+function attachSessionNotices(obj, verb, argsIn) {+  try {+    if (!obj || typeof obj !== 'object' || Array.isArray(obj) || !verb) return;+    const sess = sessionForResponse(obj, argsIn);+    if (!sess) return;+    // AN EMULATED VIEWPORT IS INVISIBLE TO THE AI THAT SET IT (John, 2026-08-27). He found a window+    // rendering ~290px narrower than the browser window while the driving thread reported the page+    // was "taking up 100% width". Both were true: a CSS-level check measures the EMULATION, so a+    // page filling 1400 of 1400 reports 100% while the user looks at 1400 of 1690. Every honest+    // in-page measurement agrees with itself and disagrees with the screen, so the override has to+    // say so on the verbs used to measure and to look.+    if (obj._viewportOverride === undefined && VIEWPORT_SENSITIVE.has(verb)) {+      const ev = sess._emulatedViewport;+      if (ev && ev.width) {+        obj._viewportOverride = `This window has an EMULATED VIEWPORT of ${ev.width}x${ev.height}`+          + (ev.deviceScaleFactor ? ` @${ev.deviceScaleFactor}x` : '')+          + `, so it is NOT tracking the real OS window. Anything you measure in the page (innerWidth, clientWidth, a bounding rect) describes the emulation, not what the user sees: a page that fills this viewport can still leave dead space on their screen. Clear it with pup_set_viewport {"reset":true} when you are done emulating.`;+      }+    }+    // #80: the restart notice, delivered to the session it happened to rather than broadcast.+    if (obj._sessionNotice === undefined) {+      const n = drainSessionNotice(sess);+      if (n) obj._sessionNotice = n;+    }+  } catch (e) {}+} function maybeAttachBugInvite(obj, verb, argsIn) {   try {     if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return;@@ -12088,33 +12116,6 @@ function maybeAttachBugInvite(obj, verb, argsIn) {         if (rep) obj._cleanupReport = rep;       }     } catch (e) {}-    // v2.0.361 (John, 2026-08-27): AN EMULATED VIEWPORT IS INVISIBLE TO THE AI THAT SET IT.-    // He found a window rendering its page ~290px narrower than the browser window, with dead space-    // down the side, and the driving thread had told him the page was "taking up 100% width". BOTH-    // were true and that is the trap: a CSS-level check (innerWidth, clientWidth, a rect) measures-    // the EMULATED viewport, so a page filling 1400 of 1400 reports 100% while the user looks at-    // 1400 of 1690. Every honest measurement an AI can make agrees with itself and disagrees with-    // the screen. So the override has to announce itself on the verbs used to MEASURE and to LOOK,-    // rather than only on the status verb nobody calls.-    try {-      if (!isProbe && obj._viewportOverride === undefined && VIEWPORT_SENSITIVE.has(verb)) {-        const _s2 = sessionForResponse(obj, argsIn);-        const _ev = _s2 && _s2._emulatedViewport;-        if (_ev && _ev.width) {-          obj._viewportOverride = `This window has an EMULATED VIEWPORT of ${_ev.width}x${_ev.height}`-            + (_ev.deviceScaleFactor ? ` @${_ev.deviceScaleFactor}x` : '')-            + `, so it is NOT tracking the real OS window. Anything you measure in the page (innerWidth, clientWidth, a bounding rect) describes the emulation, not what the user sees: a page that fills this viewport can still leave dead space on their screen. Clear it with pup_set_viewport {"reset":true} when you are done emulating.`;-        }-      }-    } catch (e) {}-    // #80: the TARGETED notice, delivered to the session it actually happened to.-    try {-      if (!isProbe && obj._sessionNotice === undefined) {-        const _s = sessionForResponse(obj, argsIn);-        const _n = _s && drainSessionNotice(_s);-        if (_n) obj._sessionNotice = _n;-      }-    } catch (e) {}     const isError = obj.success === false || !!obj.errorCode || (!!obj.error && obj.error !== '');     // A FAILURE always earns the invitation, even on a probe — that is the highest-value moment.     if (isError) { obj._reportIssues = bugReportInvite(true); return; }@@ -12134,6 +12135,12 @@ function sendJSON(res, obj, status = 200) {     // verb and the handler didn't already set its own _hint, attach the verb's     // canonical hint (+ related) from VERB_META. So EVERY pup_* call carries     // actionable guidance inline, matching the contract AD asks all bridges for.+    // v2.0.363: session notices are attached HERE, not inside maybeAttachBugInvite. That function+    // returns early on `if (obj._reportIssues) return`, and most substantive verbs already carry the+    // bug-report invite, so anything I put after that guard was unreachable for exactly the verbs+    // that matter. Two notices shipped into that dead zone before I read the control flow instead of+    // assuming it. They are independent of the invite and belong at the chokepoint itself.+    attachSessionNotices(obj, res && res._adomCommand, res && res._adomArgs);     maybeAttachBugInvite(obj, res && res._adomCommand, res && res._adomArgs);     if (obj && typeof obj === 'object' && !Array.isArray(obj)) {       const meta = res && res._adomCommand && VERB_META[res._adomCommand];