Pup - the AI's own browser

@@ -654,6 +654,28 @@ const _sessionOwnerClaims = new Map();   // sessionId -> owner string // whichever one happens to call next, which is usually NOT the thread whose window was cleaned — that is // accepted by design: it may be irrelevant to that caller and it can ignore it, but it reaches the user // eventually, which beats never surfacing at all. Capped so a storm cannot bloat a response.+// v2.0.359 (issue #80). A PER-SESSION notice, because the janitor queue above is a BROADCAST and+// this case needs the opposite. When the bridge is upgraded or restarted, pup re-adopts the windows+// underneath every live session, and tabs can end up regrouped into a different session than the+// one that opened them. The thread that opened them sees tabs vanish with no close call and no+// error: it looks like pup lost their work. That is what happened to the "fort worth" thread while+// I was installing three builds in a row, and their report (#80) correctly said the fix is not to+// stop restarting but to TELL the affected session.+//+// Broadcast is wrong here: drainCleanupReports hands the message to whichever thread calls NEXT,+// which is usually not the thread that was affected. This attaches the notice to the session it+// happened to, and clears it once that session's own next verb carries it.+function noteSessionDisruption(session, msg) {+  try { if (session && msg) session._disruptionNotice = String(msg).slice(0, 300); } catch (e) {}+}+function drainSessionNotice(session) {+  try {+    if (!session || !session._disruptionNotice) return null;+    const m = session._disruptionNotice;+    session._disruptionNotice = null;+    return m;+  } catch (e) { return null; }+} const _cleanupReports = []; const CLEANUP_REPORT_MAX = 12; function recordCleanup(msg) {@@ -2491,6 +2513,10 @@ 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(() => {});+        // #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;+        noteSessionDisruption(session, `pup's bridge restarted (upgrade or respawn) and this window was recovered. ${_tabsBack} tab(s) came back. If you opened more than that, the missing ones were regrouped rather than closed: re-open them and they will stick. pup did not close anything.`);       }       // v1.9.202 (John's icon audit): a recovered window came back with NO taskbar badge. Under       // minimalTouch the overlay is applied only on OPEN and NAVIGATE, and the re-stamp sweeps that@@ -9149,6 +9175,10 @@ async function reclaimUnmanagedWindows() {             ns._hwnd = Number(_hit.hwnd);             await tagWindowSession(_hit.hwnd, newId);             console.log(`[reclaim] "${newId}": tagged OS window ${_hit.hwnd} so it stays resolvable (was untagged: adopted windows never went through birth)`);+            // #80: an adopted window is one pup found unowned. Whichever thread it USED to belong to+            // is not addressable any more, so the notice goes on the new session and the janitor+            // queue carries the broadcast, because the original owner cannot be reached by name.+            noteSessionDisruption(ns, `pup adopted this window after a restart: it was running but no session owned it. Its original AI thread, if any, has lost its handle to it and must re-open. Nothing was closed.`);           } else {             console.log(`[reclaim] "${newId}": could not find its OS window by title — it will stay untagged and unresolvable until a later resolve succeeds`);           }@@ -9185,7 +9215,12 @@ async function reclaimUnmanagedWindows() {       }     }   } catch (e) { console.log(`[reclaim] threw: ${e.message}`); }-  if (reclaimed) console.log(`[reclaim] adopted ${reclaimed} previously-unbranded window(s)`);+  if (reclaimed) {+    console.log(`[reclaim] adopted ${reclaimed} previously-unbranded window(s)`);+    // #80: the broadcast half. A thread whose session vanished cannot be told directly (its id is+    // gone), so the janitor queue is the only channel that reaches anyone at all.+    recordCleanup(`adopted ${reclaimed} window(s) that were running with no owning session, usually after a bridge upgrade. If a thread is missing tabs it opened, they were regrouped rather than closed — re-open and they will stick.`);+  }   return reclaimed; } // Drain the window-opened ring; a new window means SOME session may have lost a tab. Cheap: one@@ -12022,6 +12057,15 @@ function maybeAttachBugInvite(obj, verb) {         if (rep) obj._cleanupReport = rep;       }     } catch (e) {}+    // #80: the TARGETED notice, delivered to the session it actually happened to.+    try {+      if (!isProbe && obj._sessionNotice === undefined) {+        const _sid = obj.sessionId || obj.window || (typeof args !== 'undefined' && args && (args.sessionId || args.window));+        const _s = _sid && sessions.get(_sid);+        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; }