Pup - the AI's own browser

@@ -7,6 +7,10 @@ Parent skill: **pup-bridge**  # pup-bridge-dev — building & shipping the Puppeteer bridge +> **Before you touch anything here, read `pup-the-goal`.** It is what pup is FOR, in John's own+> words, and every rule in it has already been broken once: passwords he should never have to type,+> windows that must never land in front of him, and finishing the job instead of deferring it.+ The canonical source of truth for the pup bridge is **this wiki repo** (`wiki.adom.inc/adom/pup-bridge`), extracted from `adom-bridge/plugins/puppeteer` on 2026-06-29 to be cloud-owned like the kicad/fusion bridges. Read `CLAUDE.md` (ownership boundary)

@@ -0,0 +1,70 @@+---+name: pup-the-goal+description: "What pup is FOR, in John's own words, and the standing rules that follow from it. Read this BEFORE any pup work and before answering him about pup. The goal: pup makes his life easier, it signs him in so he never types passwords, it never puts a window in front of him, and it gets finished rather than deferred. Trigger words: pup goal, why pup exists, pup purpose, make pup perfect, pup standing rules, password typing, shoving windows, foreground rude, pup doctrine, before touching pup."+---++# pup: what it is FOR (John, read before every change)++> "the whole fucking goal is to make pup perfect"++Everything below is his, verbatim, from the sessions where I got it wrong. It is not background+colour. Each line is a rule that a change can violate, and each one HAS been violated.++## 1. He should never type a password++> "cuz the whole point of pup is that it makes my life easier and i stopp having to type in damn+> passwords"++- **Capture is the product, not a feature.** A password typed into ANY pup window, on ANY lane, is+  stored. If capture is off on a lane, pup is broken, whatever else works. It shipped broken on the+  DEFAULT lane for weeks because capture lived only on the CDP rail and nobody checked after the lane+  switch (2.0.602 fixed it; see `pup-credentials`).+- **Never ask him to type a password to you.** Serve it from the vault, import it from his own+  browsers (`pup_import_browser_logins`, no `hostFilter` the first time), or sync it from another of+  his desktops. He offered to paste them in chat; the answer is to make pup capture them instead.+- **Verify a capture, never assume it.** `pup_credentials {}` must show the host straight after the+  sign-in. "It should have been captured" is how two of his passwords were lost.+- **Tell him what pup can do.** > "you should be telling me you can do that cuz it should be in your+  ai hints that you even return to yourself cuz no other adom users would even know that ab has that+  feature". Capability that only shows up when an AI already knows to ask for it does not exist.++## 2. His screen is his++> "why do you keep shoving windows in front of me without warning me? that's super rude"+> "you shoved the window in my face while i was busy typing in another window"++- A pup window is BEHIND his work from the instant it exists. Chrome creates it unfocused at z1,+  which is on top: park it the moment the handle resolves, and on a cold launch watch for Chrome's own+  startup window from the spawn (2.0.604, 2.0.605).+- **Warn BEFORE, never after, and make the warning do something.** > "when i just clicked that ab+  toast, i would have expected its action when i clicked the toast to open your pup window". Toast+  with `focus:{hwnd}` so the click raises it, then wait a beat, and prefer letting him click over+  raising at all.+- **Do not re-run a window-opening flow while he is working.** Debug in ONE window, or on winvm or the+  conference room box, never by opening a window per attempt on his laptop.+- Full doctrine: `pup-user-foreground`.++## 3. Finish it++> "so why the fuck are you saying 'but I'm not putting a window in front of you again tonight to+> chase it.'"++Backing off politely is not courtesy, it is leaving pup broken. If the remaining step needs his+screen, make the step safe (parked window, clickable toast) and DO it. The goal is a finished,+correct pup, not a tidy status report. Equally: know what time it is before telling him what time it+is.++## 4. Never lose his windows, never bring back what he closed++> "pup windows are supposed to be fleeting ... the user closes the window and doesn't care about them+> anymore ... you should NEVER bring back those windows"++A window he closed is gone for good; a browser PUP ended itself is restored. Those are different+things and conflating them deleted live windows (2.0.600). See `pup-user-foreground`.++## 5. When he says it is broken, he is describing reality++He said his passwords were saved in Chrome and I told him they were not. He was right that pup had+once kept them; the regression was mine. Go and MEASURE on his box (his Chrome's own `Login Data`,+pup's vault, the log) before explaining to him why something cannot work. An explanation that+contradicts what he experiences is almost always the wrong explanation.

@@ -161,6 +161,37 @@ Proof (winvm, `proof-user-close.sh`): close one of two ext windows by WM_CLOSE, within one tick and stays gone for 4 min; close the last one, the lane ends with exit code 0 and every session is forgotten; kill the browser process from outside (nonzero exit), the windows come back. +## A NEW WINDOW MUST BE BEHIND BEFORE ITS FIRST PAINT (2.0.604, John 2026-09-17)++> "why do you keep shoving windows in front of me without warning me? that's super rude." ... "you shoved+> the window in my face while i was busy typing in another window"++Chrome creates the window UNFOCUSED but at z1, directly on top of the user's work. Parking it is therefore+not a finishing touch, it is the first thing that must happen. The park used to run at the END of the open,+after the deferred navigate, the consumer-brand pass, the orphan sweep, the fit and the jump-list commit:+**4.0 seconds of a pup window sitting over his screen, on every open** (measured from his log: shown at++636 ms, parked at +4 s). Repeat that across a flow that opens a window per attempt and the desktop is+unusable.++Rules:+1. **Park the instant the handle resolves**, before any identity, fit or navigation work. It is one Win32+   call with no activation, cheap enough to hold the birth lock across.+2. **The late park is only a re-assert, and only when the window is not foreground.** Between the two, a+   human may have clicked it; a blind second park would yank their click away.+3. **Never measure "background" by the create flag.** `focused:false` is not behind, it is z1.++## Raising is a WARNING FIRST, and the warning carries the window (2.0.604)++> "i realize you just put an ab toast up warning me, but that was like a minute after you shoved the+> window in my face" ... "when i just clicked that ab toast, i would have expected its action when i+> clicked the toast to open your pup window. i believe ab lets you attach those actions now."++`pup_raise_os_window` toasted with `focus:false` and raised in the same breath, so the notification could+not be acted on and arrived with the window rather than ahead of it. Now: the toast carries+`focus:{hwnd}` (a click raises that window), it is level `warning`, and the raise waits 1.2 s behind it so+the warning reaches the screen first. An AI should prefer the toast ALONE and let the human click it,+rather than raising at all, whenever the task can wait for them.+ ## The birth grace may override FLAGS, never INPUT (2.0.584, John 2026-09-15)  R6's birth grace (8 s, no granted raise) skipped BOTH user signals inside the shared primitive, on the

@@ -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.600"+version = "2.0.634" edition = "2021" license = "MIT" 

@@ -139,6 +139,15 @@ fn main() {                     let removed: Vec<i64> = q.split('&').find_map(|kv| kv.strip_prefix("removed=")).unwrap_or("").split(',').filter_map(|x| x.parse().ok()).collect();                     let _ = req.respond(json_response(200, &pup_verbs::extdrive::take_command_for(&lane, &removed)));                 }+                // 2.0.602: the extension lane's login-capture rail. The CDP lane got captures through a+                // DevTools binding; the default lane had none, so logins typed in normal pup windows were lost.+                (Method::Post, "/extcred") => {+                    let mut raw = String::new();+                    let mut req = req;+                    let _ = req.as_reader().read_to_string(&mut raw);+                    pup_verbs::vault::on_capture_ext(&c, &raw);+                    let _ = req.respond(json_response(200, &json!({ "ok": true })));+                }                 (Method::Post, "/exthello") => {                     let mut raw = String::new();                     let mut req = req;

@@ -4,6 +4,9 @@ pub static EXTENSIONS: &[(&str, &str, &[(&str, &[u8])])] = &[     ("extension", "pup-extension", &[         ("annotate-overlay.js", include_bytes!("../../../src/extension/annotate-overlay.js")),+        ("birth.html", include_bytes!("../../../src/extension/birth.html")),+        ("birth.js", include_bytes!("../../../src/extension/birth.js")),+        ("capture-login.js", include_bytes!("../../../src/extension/capture-login.js")),         ("content.js", include_bytes!("../../../src/extension/content.js")),         ("fg-500.woff2", include_bytes!("../../../src/extension/fg-500.woff2")),         ("fg-700.woff2", include_bytes!("../../../src/extension/fg-700.woff2")),

@@ -658,6 +658,14 @@ pub fn launch_extdrive_opts(host: &dyn Host, cand: &Candidate, profile_dir: &Pat             format!("--user-data-dir={}", profile_dir.display()),             "--no-first-run".into(), "--no-default-browser-check".into(),             "--disable-quic".into(), "--media-router=0".into(),+            // 2.0.617 (John, 2026-09-18: "being asked even that once is too much"). The cold start is now+            // INVISIBLE: no startup window at all, so Chrome never draws or activates one, and the first pup+            // window is created by the extension, minimized, and shown already at the bottom. 2.0.611 had to+            // revert --no-startup-window because a windowless Chrome EXITED before its worker called home+            // (measured on his laptop: dead within 6 s; it survived on the conference-room box). The missing+            // half is --keep-alive-for-test, which holds the browser process open with no windows: measured on+            // the same laptop, alive at 6 s with the flag, dead without it. Both flags, or neither.+            "--no-startup-window".into(), "--keep-alive-for-test".into(),             // 2.0.576 CalculateNativeWinOcclusion: stock Chrome stops painting a window that is COMPLETELY covered,             // so every capture of a pup window buried under the user's maximized browser failed (0/20, 2026-09-14),             // and the debugger screencast produced no frame either. The CDP lane has always disabled it (see@@ -681,7 +689,11 @@ pub fn launch_extdrive_opts(host: &dyn Host, cand: &Candidate, profile_dir: &Pat  // profile and raise the "Action required" bubble; their settings live in MAC-protected Secure  // Preferences so pre-acknowledging is impossible. Keep ONLY pup's own extensions enabled.  args.push(format!("--disable-extensions-except={}", extensions.iter().map(|p| p.to_string_lossy().to_string()).collect::<Vec<_>>().join(","))); }-        args.push(url.to_string());+        // 2.0.632: NO url on the command line when there is none. A url argument OVERRIDES --no-startup-window+        // (the CDP lane's note said "Never pass a URL here"), and the cold lane was launched with "about:blank":+        // that made an unowned about:blank window that sat ON TOP for 18 s until the orphan sweep closed it,+        // on every cold start (measured, 2.0.631).+        if !url.is_empty() { args.push(url.to_string()); }         return host.spawn_detached(&cand.executable_path, &args, None).map_err(|e| format!("{}: {e}", cand.kind));     }     let _ = fs::create_dir_all(profile_dir);@@ -700,6 +712,12 @@ pub fn launch_extdrive_opts(host: &dyn Host, cand: &Candidate, profile_dir: &Pat         //    bot-detection reason and costs nothing: infobars are browser UI, invisible to the page.         "--start-maximized".into(), "--disable-infobars".into(),         "--silent-debugger-extension-api".into(),   // 2.0.574: see the stock list above+        // 2.0.634: the 2.0.617 pair went into the STOCK branch only, and stock is off by default, so this+        // (the default) lane still got Chrome's real startup window: a New Tab page, activated by Chrome,+        // on top of the user for the whole session at every cold start (measured on ConfRoomROG, 2.0.633).+        // Same contract as the stock list: no startup window, and keep-alive so a windowless Chrome does+        // not exit before its worker calls home (AdomLapper: dead within 6 s without it). Both or neither.+        "--no-startup-window".into(), "--keep-alive-for-test".into(),         // 2.0.493: keep the NETWORK-QUIETING flags. Dropping them (2.0.488) re-introduced the Windows Firewall         // prompt "Do you want to allow public and private networks to access this app? — Google Chrome for         // Testing" on winvm (John, 2026-09-12): Chrome's mDNS/Cast discovery binds a UDP port on ALL interfaces@@ -721,7 +739,10 @@ pub fn launch_extdrive_opts(host: &dyn Host, cand: &Candidate, profile_dir: &Pat          args.push(format!("--disable-extensions-except={}", extensions.iter().map(|p| p.to_string_lossy().to_string()).collect::<Vec<_>>().join(",")));     }-    args.push(url.to_string());+    // 2.0.633: same rule as the stock branch above (2.0.632 only patched that one; this is the DEFAULT branch).+    // An empty argument was handed to Chrome as "" and it opened its working directory as a file listing,+    // on top of the user, for the whole session (measured on ConfRoomROG: "Index of C:\Users\john\.cache\puppeteer\").+    if !url.is_empty() { args.push(url.to_string()); }     host.spawn_detached(&cand.executable_path, &args, None).map_err(|e| format!("{}: {e}", cand.kind)) } 

@@ -16,7 +16,7 @@ mod imp {     use windows_sys::Win32::UI::HiDpi::GetDpiForWindow;     use windows_sys::Win32::UI::WindowsAndMessaging::{         EnumWindows, GetClassNameW, GetForegroundWindow, GetPropW, GetWindow, GetWindowLongPtrW, GetWindowRect, GetWindowTextW, GetWindowThreadProcessId, IsWindow, IsWindowVisible,-        LoadImageW, PostMessageW, SetPropW, SetWindowPos, SystemParametersInfoW, GWL_STYLE, GW_OWNER, HWND_BOTTOM, IMAGE_ICON, LR_LOADFROMFILE, SPI_GETWORKAREA, SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, WM_SETICON, WS_CAPTION,+        LoadImageW, PostMessageW, SetPropW, SetWindowPos, SystemParametersInfoW, GWL_STYLE, GW_OWNER, HWND_BOTTOM, IMAGE_ICON, LR_LOADFROMFILE, SPI_GETWORKAREA, SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOOWNERZORDER, SWP_NOSIZE, SWP_NOZORDER, WM_SETICON, WS_CAPTION,     };      fn wide(s: &str) -> Vec<u16> { s.encode_utf16().chain(std::iter::once(0)).collect() }@@ -126,8 +126,27 @@ mod imp {             extern "system" { fn ShowWindow(hwnd: HWND, ncmd: i32) -> i32; }             unsafe { ShowWindow(hwnd as HWND, if visible { 4 /* SW_SHOWNOACTIVATE */ } else { 0 /* SW_HIDE */ }); true }         }+        fn show_at_bottom_no_activate(&self, hwnd: i64) -> bool {+            extern "system" { fn ShowWindow(hwnd: HWND, ncmd: i32) -> i32; }+            const SWP_SHOWWINDOW: u32 = 0x0040;+            unsafe {+                // Z-ORDER FIRST, then draw. The window arrives here hidden (the lane watcher) or minimized+                // (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.+                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 */);+                SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_SHOWWINDOW) != 0+            }+        }+        // 2.0.626: THE flag. MEASURED on the conference-room box, 2026-09-18, straight from a fresh process:+        // SetWindowPos(HWND_BOTTOM, NOMOVE|NOSIZE|NOACTIVATE) on a pup Chrome window returned TRUE and moved it to+        // rank 0, THE TOP, where it stayed; the same call with SWP_NOOWNERZORDER put it at rank 25, the bottom, and+        // it stayed. Chrome's frame owns helper windows, and without SWP_NOOWNERZORDER Windows re-orders the owner+        // together with them. So every "parked at z-bottom: true" this week was a RAISE: the birth flash, the+        // "navigate surfaces it", the lower that "succeeded" with the window still on top. One flag.         fn send_to_bottom_no_activate(&self, hwnd: i64) -> bool {-            unsafe { SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE) != 0 }+            unsafe { SetWindowPos(hwnd as HWND, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER) != 0 }         }         // Node: healOffscreenWindow / setSessionWindowBounds (SetWindowPos 0x14 = NOACTIVATE|NOZORDER)         fn set_bounds_no_activate(&self, hwnd: i64, left: i32, top: i32, width: i32, height: i32) -> bool {

@@ -51,6 +51,10 @@ pub trait HostWindows: Send + Sync {     /// ShowWindow(SW_HIDE) / ShowWindow(SW_SHOWNOACTIVATE): a hidden window has no taskbar button; showing it     /// creates the button ONCE with whatever identity the window carries by then.     fn set_visible_no_activate(&self, hwnd: i64, visible: bool) -> bool { let _ = (hwnd, visible); false }+    /// 2.0.612: SetWindowPos(HWND_BOTTOM, SWP_SHOWWINDOW | SWP_NOACTIVATE): make a hidden window visible+    /// ALREADY at the bottom, in ONE call. Showing first and lowering after leaves a frame where the user+    /// sees it in front, which is the whole complaint.+    fn show_at_bottom_no_activate(&self, hwnd: i64) -> bool { let _ = hwnd; false }     /// ITaskbarList::DeleteTab / AddTab: remove or (re)create the taskbar button WITHOUT touching the     /// window (no hide, so Chrome queues no activation). AddTab creates the button fresh with whatever     /// AUMID/icon the window carries at that moment.

@@ -561,6 +561,26 @@ fn window_id_for_hwnd(ctx: &Ctx, sid: &str) -> Option<i64> {     r["tabs"].as_array()?.iter().find(|t| t["tabId"].as_i64() == Some(want)).and_then(|t| t["windowId"].as_i64()) } +/// 2.0.630: bind a newborn by its birth token, deterministically (pup-window-targeting R4, pup-no-wiggle). The+/// extension creates every window on birth.html, whose title is "PUPBIRTH-<token>", so the one lane window+/// carrying that title IS this session's, however many windows are being born at once and whatever placeholder+/// Chrome makes at launch. No width filter: the window is still MINIMIZED here, and a minimized window reports+/// a tiny rect at -32000, which is exactly the shape the geometry filters exclude.+pub(crate) fn hwnd_by_birth_token(ctx: &Ctx, token: &str, taken: &std::collections::HashSet<i64>, wait: Duration) -> Option<i64> {+    let want = format!("PUPBIRTH-{token}");+    let t0 = std::time::Instant::now();+    loop {+        let pids = crate::extdrive_pids();+        if !pids.is_empty() {+            let m: Vec<i64> = ctx.host.windows_for_pids(&pids, Some("Chrome_WidgetWin_1")).into_iter()+                .filter(|w| w.title.starts_with(&want) && !taken.contains(&w.hwnd)).map(|w| w.hwnd).collect();+            if m.len() == 1 { return Some(m[0]); }+        }+        if t0.elapsed() >= wait { return None; }+        std::thread::sleep(Duration::from_millis(25));+    }+}+ pub(crate) fn lane_hwnd_for(ctx: &Ctx, s: &pup_session::Session) -> Option<i64> {     let pids = crate::extdrive_pids();     if pids.is_empty() { return None; }

@@ -229,6 +229,21 @@ fn open_on(ctx: &Ctx, caller: &Caller, args: &Value, url: &str) -> Result<Opened     Ok(Opened { sid, tab, new_window }) } +/// 2.0.603 (John, 2026-09-17: "whenever you need the users attention for a password, you should do it+/// that way" ... "i didn't even realize you were waiting on me. why did you not ab toast me?"). Every+/// answer that parks the flow on the human toasts, and the toast CARRIES THE WINDOW: ab's `focus` makes a+/// click bring that pup window to the front, so the user lands on the exact page that is waiting.+pub(crate) fn toast_waiting(ctx: &Ctx, caller: &Caller, sid: &str, title: &str, body: &str) {+    let hwnd = ctx.sessions.get(sid).and_then(|s| s.hwnd).filter(|h| *h > 0);+    let mut args = json!({ "title": title, "body": body, "level": "warning" });+    match hwnd {+        Some(h) => args["focus"] = json!({ "hwnd": h }),+        None => args["focus"] = json!({ "app": "chrome.exe" }),+    }+    let _ = ctx.ab.call("notify_user", args, caller, Duration::from_secs(8));+    pup_core::log(format!("[cred] toasted the user: {title} (click opens window \"{sid}\")"));+}+ fn account_line(a: &Value) -> String {     let labels: Vec<String> = a["labels"].as_array().map(|l| l.iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect()).unwrap_or_default();     let mut parts = vec![a["kind"].as_str().unwrap_or("?").to_string()];@@ -257,6 +272,15 @@ fn finish(ctx: &Ctx, caller: &Caller, sid: &str, account: Option<&str>, cont: &s     }     let p = phase(&st);     let acct = account.unwrap_or("the account");+    if matches!(p, "choose" | "code" | "challenge" | "wrong_password") {+        let (t, b) = match p {+            "code" => ("pup needs the code Google just sent", format!("Google sent a verification code for {acct}. Click here to open the pup window, or tell your AI thread the code.")),+            "choose" => ("Google wants a second step", format!("Pick how to verify {acct}. Click here to open the pup window.")),+            "wrong_password" => ("pup's saved password is out of date", format!("Google rejected the stored password for {acct}. Click here to open the pup window and sign in once; pup will save the new one.")),+            _ => ("Google is waiting for you", format!("Approve the sign-in for {acct} on your phone, or click here to open the pup window.")),+        };+        toast_waiting(ctx, caller, sid, t, &b);+    }     let base = json!({ "account": account, "window": sid, "url": st["url"], "step": p });     match p {         "left" => {@@ -353,6 +377,11 @@ pub fn google_signin(ctx: &Ctx, caller: &Caller, args: &Value) -> Value { }  fn signin_impl(ctx: &Ctx, caller: &Caller, args: &Value) -> Value {+    // 2.0.621: no screen handback (pup-user-foreground: deleted in August, it foregrounded the wrong window).+    signin_inner(ctx, caller, args)+}++fn signin_inner(ctx: &Ctx, caller: &Caller, args: &Value) -> Value {     let want = args["account"].as_str().map(|s| s.trim().to_lowercase()).filter(|s| !s.is_empty());     // finishing a verification step in the window a previous call left on it     if args.get("code").and_then(|c| c.as_str()).is_some() || args.get("challenge").and_then(|c| c.as_str()).is_some() {@@ -410,6 +439,8 @@ fn signin_impl(ctx: &Ctx, caller: &Caller, args: &Value) -> Value {      let Some(cred) = ctx.vault.get_user(&*ctx.host, "https://accounts.google.com/", &account) else {         let found_in: Vec<String> = info["browsers"].as_array().map(|b| b.iter().filter_map(|x| x.as_str().map(|s| s.to_string())).collect()).unwrap_or_default();+        toast_waiting(ctx, caller, &sid, "pup needs you to sign in once",+            &format!("Sign in as {account} in the pup window (click here to open it). pup saves the password and will not ask again."));         return pup_core::merge(err("google_password_missing", format!("{account} is not signed into pup and pup has no saved password for it"),             Some(&format!("{} Get the password into pup's vault once, then call pup_google_signin again: pup_import_browser_logins {{hostFilter:\"google.com\"}} with NO hostFilter reads the user's own saved Chrome/Edge/Brave logins from EVERY profile into pup's vault: tell the user to approve the Adom Bridge consent (inside Hydrogen it arrives as a notification and a card, not a window) and then a Windows admin prompt; no one sees the password, and if the call answers consent_pending, call it again to collect the result. Know the limit before you promise it: a browser does NOT save the password of the account it is itself signed in as, so a user's everyday Google account is usually absent however wide the import (measured on John's laptop: 828 logins imported, 240 of them under [email protected], and not one for google.com). For those accounts the only route is the user signing in once in this pup window, which pup captures on submit, or the user signs in once in window \"{sid}\" and pup captures it. Never ask the user to type the password to you.", if found_in.is_empty() { String::new() } else { format!("The account is signed into {} on this desktop, so its browser most likely has the password saved.", found_in.join(", ")) }))),             json!({ "account": account, "window": sid, "foundIn": found_in }));

@@ -57,6 +57,11 @@ pub fn import_browser_logins(ctx: &Ctx, caller: &Caller, args: &Value) -> Value         { let mut g = IMPORT_JOB.lock().unwrap(); if let Some(r) = g.as_ref().and_then(|j| j.result.clone()) { *g = None; return r; } }         std::thread::sleep(Duration::from_millis(500));     }+    // 2.0.603: say it on the desktop, not only in the answer. The consent arrives as a Bridge notification+    // inside Hydrogen, which is easy to miss: John sat unaware twice while pup waited (2026-09-16).+    let _ = ctx.ab.call("notify_user", json!({ "title": "pup is waiting for your approval",+        "body": "Approve the Adom Bridge request to read your saved browser logins, then the Windows prompt. pup uses them to sign you in without asking for passwords.",+        "level": "warning", "focus": { "host": true } }), caller, Duration::from_secs(8));     let other = IMPORT_JOB.lock().unwrap().as_ref().map(|j| j.key != key).unwrap_or(false);     pup_core::merge(err("consent_pending", "Waiting for the user to approve the import on their desktop", Some(&format!("{}The user approves an Adom Bridge consent (when Bridge runs inside Hydrogen it arrives as a notification and a card in Hydrogen, not a window), then a Windows admin prompt. Tell the user exactly that, then call pup_import_browser_logins again with the same arguments: it re-attaches to this request and returns the result, it does not raise a second prompt. After 2 minutes with no answer Bridge counts it as declined.", if other { "An import with different arguments is already waiting; this call attached to it. " } else { "" }))),         json!({ "pending": true, "output": json!({ "ok": false, "pending": true }).to_string() }))

@@ -41,7 +41,12 @@ pub fn bottom_unless_foreground(ctx: &Ctx, sid: &str, force: bool) -> &'static s         let idle = ctx.host.idle_ms().unwrap_or(u64::MAX);         let since_birth = pup_core::now_ms().saturating_sub(s.born_at_ms);         let remembered = s.user_active_at_ms > 0 && pup_core::now_ms().saturating_sub(s.user_active_at_ms) < USER_MEMORY_MS;-        let chrome_self_raise = in_birth_grace(&s) && !crate::transport::is_ext(&s) && !remembered && idle >= since_birth;+        // 2.0.628: the extension lane is no longer excluded. The exclusion rested on "Chrome never self-activates+        // an unfocused-created window on this lane", which is true for a warm birth and FALSE for the first+        // window of a freshly started browser: measured 2026-09-18, the cold-birth re-assert answered+        // "foreground" with no input since birth, while a Notepad window held the keyboard a second earlier.+        // The idle-hands rule is lane-independent: no input since birth means Chrome raised it, not a person.+        let chrome_self_raise = in_birth_grace(&s) && !remembered && idle >= since_birth;         if chrome_self_raise {             pup_core::log(format!("[park] \"{sid}\" is foreground {since_birth} ms after birth with no input since birth: Chrome's self-raise, bottoming"));         } else {

@@ -40,6 +40,11 @@ pub fn navigate(lane: &Lane, t: &Tab, url: &str) -> Result<(String, String, bool         },         Lane::Ext => {             let r = run(json!({ "action": "navigate", "url": url, "tabId": ext_id(t) }), 60)?;+            // 2.0.619: say WHICH path loaded the page. chrome.tabs.update surfaces the window (measured), so+            // Page.navigate over DevTools is preferred and a fallback to the tab API is worth seeing in the log.+            if r["navVia"].as_str() == Some("tabs") {+                pup_core::log(format!("[nav] fell back to the tab API (the window may surface): {}", r["navErr"].as_str().unwrap_or("no reason given")));+            }             Ok((r["url"].as_str().unwrap_or(url).to_string(), r["title"].as_str().unwrap_or("").to_string(), true))         }     }

@@ -16,6 +16,22 @@ pub const CAPTURE_LOGIN_JS: &str = include_str!("../assets/capture-login.js");  pub fn capture_login_script() -> String { CAPTURE_LOGIN_JS.replace("${BRIDGE_VERSION}", pup_core::version()) } +/// POST /extcred from the extension lane's capture script (2.0.602). Same record shape as the CDP+/// binding, minus a CDP session id: the session hint is resolved by host instead.+pub fn on_capture_ext(ctx: &Ctx, raw: &str) {+    if ctx.settings.get("captureLogins", "on") == "off" { return; }+    let rec: Value = serde_json::from_str(raw).unwrap_or(json!({}));+    let (host, user, pass) = (rec["host"].as_str().unwrap_or(""), rec["u"].as_str().unwrap_or(""), rec["p"].as_str().unwrap_or(""));+    if host.is_empty() || pass.is_empty() { return; }+    if let Some(c) = ctx.vault.get_for_url(&*ctx.host, &format!("https://{host}/"), if user.is_empty() { None } else { Some(user) }) {+        if c.password == pass && (user.is_empty() || c.username == user) { ctx.vault.touch_used_user(&c.host, &c.username); return; }+    }+    match ctx.vault.set(&*ctx.host, host, if user.is_empty() { "(unknown)" } else { user }, pass) {+        Ok(_) => pup_core::log(format!("[cred] captured login for {host}{} (extension lane) → OS keychain", if user.is_empty() { String::new() } else { format!(" ({user})") })),+        Err(e) => pup_core::log(format!("[cred] capture store failed: {e}")),+    }+}+ /// Runtime.bindingCalled "__pupCredCapture" from the capture script: store the login. pub fn on_capture(ctx: &Ctx, sid_cdp: &str, payload: &str) {     if ctx.settings.get("captureLogins", "on") == "off" { return; }@@ -281,7 +297,11 @@ fn login_ext(ctx: &Ctx, caller: &Caller, args: &Value, s: Session) -> Value {         (Some(u), Some(p)) if !p.is_empty() => { if args["save"].as_bool() == Some(true) { let _ = ctx.vault.set(&*ctx.host, &live_host, u, p); } (u.into(), p.into(), "args".into()) }         _ => match ctx.vault.get_for_url(&*ctx.host, &cur_url, args["preferAccount"].as_str()) {             Some(c) => (c.username, c.password, format!("vault:{}", c.host)),-            None => return err("no_credential", format!("no saved login matches {live_host}"), Some(IMPORT_HINT)),+            None => {+                crate::google::toast_waiting(ctx, caller, &s.id, "pup needs a login it does not have",+                    &format!("Sign in to {live_host} once in the pup window (click here to open it) and pup will remember it."));+                return err("no_credential", format!("no saved login matches {live_host}"), Some(IMPORT_HINT));+            }         },     };     let submit = args["submit"].as_bool() == Some(true);

@@ -32,7 +32,14 @@ pub fn raise(ctx: &Ctx, caller: &Caller, args: &Value) -> Value {         let ms: u64 = ctx.settings.get("fgCaptionMs", "3500").parse().unwrap_or(3500);         let _ = ctx.ab.call("desktop_caption", json!({ "text": format!("{thread}: {reason}"), "duration": ms, "expiresInMs": ms, "position": "bottom", "size": "medium", "id": format!("pup-fg-{}", s.id) }), caller, AB_T);     }-    let _ = ctx.ab.call("notify_user", json!({ "title": format!("pup: {thread} is showing you a window"), "body": reason, "focus": false, "level": "info" }), caller, AB_T);+    // 2.0.604 (John, 2026-09-17: "why do you keep shoving windows in front of me without warning me?+    // that's super rude" / "i realize you just put an ab toast up warning me, but that was like a minute+    // after you shoved the window in my face while i was busy typing in another window"). The toast used to+    // carry focus:false, so clicking it did nothing, and it landed in the same instant as the window, which+    // is not a warning at all. Now it CARRIES THE WINDOW (a click raises it) and the raise waits a beat+    // behind it, so the notification reaches the screen first.+    let _ = ctx.ab.call("notify_user", json!({ "title": format!("pup: {thread} needs this window on your screen"), "body": reason, "focus": { "hwnd": h }, "level": "warning" }), caller, AB_T);+    std::thread::sleep(Duration::from_millis(1200));     let r = ctx.ab.call("desktop_bring_to_front", json!({ "hwnd": h }), caller, AB_T);     let applied = r.is_ok();     if !applied { let _ = ctx.ab.call("desktop_window_show", json!({ "hwnd": h }), caller, AB_T); }

@@ -0,0 +1,9 @@+<!doctype html>+<!-- pup birth page (2.0.630). Every extension-lane window is CREATED on this page, minimized, with a unique+     token in the query string; the page's <title> is that token, so the OS window title is+     "PUPBIRTH-<token> - Google Chrome for Testing" from the first instant, and pup binds the window by that+     title alone: deterministic, no set-diff, no geometry (pup-no-wiggle, pup-window-targeting R4). The real+     URL is navigated to only after the window is bound and parked at the bottom of the z-order. -->+<html><head><meta charset="utf-8"><title>PUPBIRTH</title>+<style>html,body{margin:0;background:#161b22;color:#8b949e;font:14px system-ui}</style>+<script src="birth.js"></script></head><body></body></html>

@@ -0,0 +1,5 @@+// pup birth page script (2.0.632). Lives in its own file because an extension page's default content+// security policy refuses inline scripts: an inline version left every title at plain "PUPBIRTH", so pup's+// token lookup timed out on every open and the window showed for the 3 s it waited (measured, 2.0.631).+const t = new URLSearchParams(location.search).get('token') || '';+if (t) document.title = 'PUPBIRTH-' + t;

@@ -0,0 +1,64 @@+// pup login capture on the EXTENSION lane (2.0.602).+//+// John, 2026-09-17, after typing his Google password into a pup window and finding pup had not kept it:+// "are you fucking kidding me? i did type in my fucking password ... the whole point of pup is that it+// makes my life easier and i stop having to type in damn passwords".+//+// The capture rail existed ONLY on the CDP lane (Page.addScriptToEvaluateOnNewDocument plus the+// __pupCredCapture binding, installed in lib.rs tab-setup and recovery). The extension lane has no CDP+// page instrumentation, and it is the DEFAULT lane, so every login typed in a normal pup window was+// thrown away. This is the same detection logic as rust/verbs/assets/capture-login.js, delivering through+// the service worker instead of a DevTools binding.+//+// Runs in the ISOLATED world (chrome.runtime is needed to reach the worker); it still reads the page's+// DOM, so input.value is available. The MAIN-world HTMLFormElement.prototype.submit hook from the CDP+// copy cannot be installed from here, so a purely programmatic form.submit() is covered by the blur,+// change, keydown and pagehide nets instead.+(() => {+  if (window !== window.top) return;+  if (window.__pupExtCapV === '1') return;+  window.__pupExtCapV = '1';+  const vis = (el) => !!el && !el.disabled && el.offsetParent !== null && el.getClientRects().length > 0;+  const isPwd = (el) => el && el.tagName === 'INPUT' && (el.type === 'password' || el.autocomplete === 'current-password' || el.autocomplete === 'new-password' || /(^|[^a-z])password([^a-z]|$)/i.test(el.name || '') || /(^|[^a-z])password([^a-z]|$)/i.test(el.id || ''));+  let last = '';+  function grab(form) {+    try {+      const scope = form || document;+      const pwd = [...scope.querySelectorAll('input')].filter(vis).filter(isPwd)[0];+      if (!pwd || !pwd.value) return;+      const all = [...scope.querySelectorAll('input')];+      const pi = all.indexOf(pwd);+      let user = [...scope.querySelectorAll('input[autocomplete=username], input[type=email]')].filter(vis).filter((e) => !isPwd(e))[0];+      if (!user) {+        const cands = [...scope.querySelectorAll('input[type=text], input[type=tel], input:not([type])')].filter(vis).filter((e) => !isPwd(e));+        user = cands.slice().reverse().filter((c) => all.indexOf(c) < pi)[0] || cands[0] || null;+      }+      // Google asks for the email on one page and the password on the next, so the password page has no+      // username field at all. Take the address Google prints on it (measured on the real sign-in page).+      let u = user ? user.value : '';+      if (!u && /(^|\.)google\.com$/.test(location.hostname)) {+        const m = (document.body.innerText || '').match(/[\w.+-]+@[\w.-]+\.\w+/);+        if (m) u = m[0];+      }+      const rec = { host: location.hostname, u, p: pwd.value, ts: Date.now() };+      const key = rec.host + '|' + rec.u + '|' + rec.p;+      if (key === last) return;   // blur then submit then pagehide all fire for one login+      last = key;+      chrome.runtime.sendMessage({ t: 'pup-cred', rec }, () => void chrome.runtime.lastError);+    } catch (e) {}+  }+  const formHasPwd = (f) => { try { return !!f && [...f.querySelectorAll('input')].some(isPwd); } catch (e) { return false; } };+  addEventListener('submit', (e) => grab(e.target && e.target.tagName === 'FORM' ? e.target : null), true);+  addEventListener('click', (e) => {+    try {+      const t = e.target && e.target.closest && e.target.closest('button, input[type=submit], [role=button], a');+      if (!t) return;+      const f = t.form || (t.closest && t.closest('form'));+      if (formHasPwd(f)) grab(f); else if (!f) grab(null);+    } catch (e2) {}+  }, true);+  addEventListener('change', (e) => { try { if (isPwd(e.target) && e.target.value) grab(e.target.form || null); } catch (e2) {} }, true);+  addEventListener('blur', (e) => { try { if (isPwd(e.target) && e.target.value) grab(e.target.form || null); } catch (e2) {} }, true);+  addEventListener('keydown', (e) => { try { if (e.key === 'Enter' && isPwd(document.activeElement) && document.activeElement.value) grab(document.activeElement.form || null); } catch (e2) {} }, true);+  addEventListener('pagehide', () => { try { grab(null); } catch (e2) {} }, true);+})();

@@ -1,7 +1,7 @@ {   "manifest_version": 3,   "name": "Adom Pup",-  "version": "0.4.4",+  "version": "0.4.14",   "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",