Pup - the AI's own browser

@@ -4,7 +4,7 @@ members = ["core", "host", "host-win", "host-mac", "cdp", "browser", "session",  # One version for the whole bridge, in lockstep with src/BRIDGE_VERSION (tools/ship.sh bumps both). [workspace.package]-version = "2.0.634"+version = "2.0.641" edition = "2021" license = "MIT" 

@@ -211,8 +211,12 @@ pub fn set_log_file(path: std::path::PathBuf) { } pub fn log_file() -> Option<std::path::PathBuf> { LOG_FILE.get().and_then(|m| m.lock().unwrap().clone()) } +static LAST_LOG: std::sync::Mutex<String> = std::sync::Mutex::new(String::new());+/// The most recent log line (2.0.636): lets a watcher say what pup had just done when something moved.+pub fn last_log() -> String { LAST_LOG.lock().map(|l| l.clone()).unwrap_or_default() } pub fn log(line: impl AsRef<str>) {     let line = line.as_ref();+    if !line.starts_with("[zwatch]") { if let Ok(mut l) = LAST_LOG.lock() { *l = line.chars().take(120).collect(); } }     println!("{line}");     let Some(path) = log_file() else { return };     use std::io::Write;@@ -224,7 +228,7 @@ pub fn now_ms() -> u64 { std::time::SystemTime::now().duration_since(std::time::  pub fn iso_now() -> String {     // No chrono dependency: ISO-8601 UTC from the unix clock.-    let secs = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);+    let dur = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default(); let secs = dur.as_secs(); let ms = dur.subsec_millis();     let days = secs / 86400; let rem = secs % 86400;     let (h, m, s) = (rem / 3600, (rem % 3600) / 60, rem % 60);     // civil-from-days (Howard Hinnant)@@ -233,7 +237,7 @@ pub fn iso_now() -> String {     let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); let mp = (5 * doy + 2) / 153;     let d = doy - (153 * mp + 2) / 5 + 1; let mo = if mp < 10 { mp + 3 } else { mp - 9 };     let y = if mo <= 2 { y + 1 } else { y };-    format!("{y:04}-{mo:02}-{d:02}T{h:02}:{m:02}:{s:02}.000Z")+    format!("{y:04}-{mo:02}-{d:02}T{h:02}:{m:02}:{s:02}.{ms:03}Z") }  /// Background-loop cadence stats (Node: _loopStats / loopReport) for pup_status.loops.

@@ -122,9 +122,56 @@ mod imp {                 ok             }         }+        fn park_on_first_show(&self, hwnd: i64, timeout_ms: u64) -> Option<u64> {+            extern "system" { fn IsWindowVisible(hwnd: HWND) -> i32; fn GetForegroundWindow() -> HWND; }+            let t0 = std::time::Instant::now();+            unsafe {+                while IsWindowVisible(hwnd as HWND) == 0 {+                    if t0.elapsed().as_millis() as u64 > timeout_ms { return None; }+                    std::thread::sleep(std::time::Duration::from_micros(100));+                }+                let shown = t0.elapsed().as_millis() as u64;+                SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);+                let t1 = std::time::Instant::now();+                // 2.0.641: Chrome re-tops the window during its first frames (z-watch: a 22 ms episode inside the+                // 1 ms-cadence hold). Spin without sleeping for the first 100 ms so the gap between Chrome's+                // re-top and pup's re-bottom is microseconds, under one composed frame; then 1 ms until 300 ms.+                while t1.elapsed().as_millis() < 300 {+                    if GetForegroundWindow() as i64 != hwnd { SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER); }+                    if t1.elapsed().as_millis() < 100 { std::thread::yield_now(); } else { std::thread::sleep(std::time::Duration::from_millis(1)); }+                }+                Some(shown)+            }+        }+        fn stop_flash(&self, hwnd: i64) -> bool {+            #[repr(C)] struct FLASHWINFO { cb_size: u32, hwnd: HWND, flags: u32, count: u32, timeout: u32 }+            extern "system" { fn FlashWindowEx(p: *const FLASHWINFO) -> i32; }+            let f = FLASHWINFO { cb_size: std::mem::size_of::<FLASHWINFO>() as u32, hwnd: hwnd as HWND, flags: 0 /* FLASHW_STOP */, count: 0, timeout: 0 };+            unsafe { FlashWindowEx(&f); true }+        }         fn set_visible_no_activate(&self, hwnd: i64, visible: bool) -> bool {-            extern "system" { fn ShowWindow(hwnd: HWND, ncmd: i32) -> i32; }-            unsafe { ShowWindow(hwnd as HWND, if visible { 4 /* SW_SHOWNOACTIVATE */ } else { 0 /* SW_HIDE */ }); true }+            extern "system" { fn ShowWindow(hwnd: HWND, ncmd: i32) -> i32; fn GetWindow(hwnd: HWND, cmd: u32) -> HWND; fn IsWindow(hwnd: HWND) -> i32; }+            // 2.0.636: a hidden window that is re-shown, even with SW_SHOWNOACTIVATE, comes back at the TOP of+            // its band: the taskbar-button rebuild (hide + re-show) put a background pup window over the user's+            // work for a sample (measured on the conference-room box, 2026-09-19, 01:07:56). Remember the window+            // that was directly above it at hide time and re-insert under that one on show; if that window is+            // gone, the bottom. Never the top, never activated.+            static PREV: std::sync::Mutex<Vec<(i64, i64)>> = std::sync::Mutex::new(Vec::new());+            const GW_HWNDPREV: u32 = 3;+            unsafe {+                if !visible {+                    let prev = GetWindow(hwnd as HWND, GW_HWNDPREV) as i64;+                    let mut m = PREV.lock().unwrap_or_else(|e| e.into_inner());+                    m.retain(|(h, _)| *h != hwnd); m.push((hwnd, prev));+                    ShowWindow(hwnd as HWND, 0 /* SW_HIDE */); return true;+                }+                let prev = { let mut m = PREV.lock().unwrap_or_else(|e| e.into_inner()); let p = m.iter().find(|(h, _)| *h == hwnd).map(|(_, p)| *p); m.retain(|(h, _)| *h != hwnd); p };+                let after: HWND = match prev { Some(p) if p != 0 && IsWindow(p as HWND) != 0 => p as HWND, _ => HWND_BOTTOM };+                SetWindowPos(hwnd as HWND, after, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);+                ShowWindow(hwnd as HWND, 4 /* SW_SHOWNOACTIVATE */);+                SetWindowPos(hwnd as HWND, after, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);+                true+            }         }         fn show_at_bottom_no_activate(&self, hwnd: i64) -> bool {             extern "system" { fn ShowWindow(hwnd: HWND, ncmd: i32) -> i32; }@@ -134,8 +181,11 @@ mod imp {                 // (chrome.windows.create state:minimized), and both restore ON TOP if you show them first.                 // Bottom it while it is still not on screen, restore it without activating, then bottom it                 // once more in case the restore re-ordered it. The user never sees a frame of it in front.+                extern "system" { fn IsWindowVisible(hwnd: HWND) -> i32; fn IsIconic(hwnd: HWND) -> i32; }                 SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);-                ShowWindow(hwnd as HWND, 4 /* SW_SHOWNOACTIVATE */);+                // 2.0.640: ShowWindow(SW_SHOWNOACTIVATE) on a window that is ALREADY visible and not minimized+                // re-raises it (z-watch: 19 ms on top on every birth, 2.0.639). Only show what needs showing.+                if IsWindowVisible(hwnd as HWND) == 0 || IsIconic(hwnd as HWND) != 0 { ShowWindow(hwnd as HWND, 4 /* SW_SHOWNOACTIVATE */); }                 SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_SHOWWINDOW) != 0             }         }

@@ -62,6 +62,16 @@ pub trait HostWindows: Send + Sync {     /// Move/resize without activation or z-order change.     fn set_bounds_no_activate(&self, hwnd: i64, left: i32, top: i32, width: i32, height: i32) -> bool;     fn foreground(&self) -> i64;+    /// 2.0.637: stop a taskbar flash / clear the attention tint NATIVELY (FlashWindowEx FLASHW_STOP). Never+    /// activates or re-orders anything. Replaces ab's desktop_clear_window_attention on pup's own paths, which+    /// RAISES and briefly ACTIVATES the window (adom-bridge#199; z-watch measured 40-80 ms of the newborn as the+    /// foreground window on every birth).+    fn stop_flash(&self, hwnd: i64) -> bool { let _ = hwnd; false }+    /// 2.0.640: spin (sub-millisecond) until `hwnd` becomes visible, order it to the bottom in that same+    /// instant, and keep it there for the first 300 ms unless the user has made it the foreground. Returns+    /// the ms until the first show, None if it never showed within `timeout_ms`. A per-poll EnumWindows was+    /// 22 ms behind Chrome's first show (z-watch, 2.0.639); the compositor paints a frame in 16.+    fn park_on_first_show(&self, hwnd: i64, timeout_ms: u64) -> Option<u64> { let _ = (hwnd, timeout_ms); None }     /// Milliseconds since the last keyboard/mouse input (GetLastInputInfo); None where unknown.     fn idle_ms(&self) -> Option<u64> { None }     /// The primary monitor's work area (x, y, w, h), excluding the taskbar.

@@ -130,6 +130,18 @@ pub fn clear_attention(ctx: &Ctx, hwnd: i64, caller: &Caller) -> String {  /// The birth signal: `flash` = finite four-count orange flash (never forever); `progress` = the /// icon-apply bar (started by the caller) plus the attention-tint clear; `off` = only the clear.+/// 2.0.637: clear the attention tint the open/navigate flash leaves, WITHOUT ab. ab's clear verb raises and+/// briefly activates the window (adom-bridge#199): the z-watch saw every newborn become the FOREGROUND window+/// for 40-80 ms about a second after the jump list committed, which the foreground gate caught one run in three.+/// Let the pulses show, then stop the flash natively; a window the user has foregrounded is left alone.+pub fn clear_attention_later(ctx: &Ctx, hwnd: i64) {+    if !cfg!(windows) { return; }+    let Some(a) = ctx.arc() else { return };+    std::thread::Builder::new().name("flash-stop".into()).spawn(move || {+        std::thread::sleep(Duration::from_millis(2500));+        if a.host.foreground() != hwnd { a.host.stop_flash(hwnd); }+    }).ok();+} pub fn on_open(ctx: &Ctx, sid: &str, hwnd: i64, caller: &Caller) {     if !cfg!(windows) { return; }     if mode(ctx) == "flash" && !minimal_touch(ctx) { let _ = ctx.ab.call("desktop_flash_window", json!({ "hwnd": hwnd, "mode": "count", "count": 4 }), caller, Duration::from_secs(6)); ctx.sessions.with_mut(sid, |x| x.flash_count += 1); }

@@ -636,7 +636,7 @@ fn with_lane_progress<T>(ctx: &Ctx, work: impl FnOnce() -> T) -> T { /// since 2.0.568). The in-page JS composer this used to carry is gone. fn dress_after(ctx: &Ctx, caller: &Caller) {     let Some(hwnd) = lane_hwnd(ctx) else { return };-    let _ = crate::activity::clear_attention(ctx, hwnd, caller);+    crate::activity::clear_attention_later(ctx, hwnd);   // 2.0.637: never ab's clear here (it raises + activates)     if ctx.settings.get("overlayBadges", "on") == "off" { return; }     for s in ctx.sessions.all().into_iter().filter(|s| crate::transport::is_ext(s) && s.hwnd.is_some()) { crate::identity::overlay(ctx, &s.id, caller); } }

@@ -1,7 +1,7 @@ {   "manifest_version": 3,   "name": "Adom Pup",-  "version": "0.4.14",+  "version": "0.4.15",   "description": "Toolbar for Adom Pup browser windows: annotate, snip, view toggle, dashboard, owner info. Thin trigger surface - the pup bridge is the engine.",   "action": {     "default_popup": "popup.html",

@@ -264,7 +264,11 @@ async function pupExtPollOnce() {       // real window came up unparked (measured: 4.5 s on top on every cold start). The caller navigates to       // the real URL after the window is bound and parked; `url` here only says where it will go.       const token = Math.random().toString(36).slice(2, 10) + Date.now().toString(36);-      const w = await chrome.windows.create({ url: chrome.runtime.getURL('birth.html') + '?token=' + token, focused: false, state: 'minimized' });+      // 0.4.15: NORMAL, unfocused. The minimized birth still showed the window ON TOP for 140-250 ms before its+      // minimize (z-watch, 2.0.638) and surfaced again for ~20 ms when pup restored it. pup now parks the window+      // while it is still invisible (the birth watcher catches it ~150 ms before the first show), so there is no+      // reason to minimize and no restore to surface.+      const w = await chrome.windows.create({ url: chrome.runtime.getURL('birth.html') + '?token=' + token, focused: false, state: 'normal' });       const birthMoveMs = 0;       const tab = w.tabs && w.tabs[0];       if (tab) await pupExtWaitComplete(tab.id, 8000);