NB - Native Browser Bridge

@@ -20,15 +20,29 @@ function windowExists(winId) { async function ensureLoaded() {   if (loaded) return;   loaded = true;+  await reconcile();+}+// Re-read the persisted map, MERGE it into memory (never lose an in-memory session that hasn't been+// persisted yet), and reconcile against LIVE windows. A session whose window no longer exists is MOVED+// to _closedSessions - NOT silently dropped - so a later verb reports "closed" and NEVER falls back to+// the user's active tab. Safe to call anytime; nbrowser_resync_sessions calls it. This is what makes+// tracking survive SW sleep + external window closes (SetForegroundWindow / WM_CLOSE from another tool).+async function reconcile() {   try {     const got = await chrome.storage.local.get(SKEY);     const obj = got[SKEY];     if (obj) {-      seq = obj.seq || 0;-      for (const [sid, winId] of obj.sessions || []) sessionWindows.set(sid, winId);-      for (const [sid, winId] of [...sessionWindows]) if (!(await windowExists(winId))) sessionWindows.delete(sid);+      seq = Math.max(seq, obj.seq || 0);+      for (const [sid, winId] of obj.sessions || []) if (!sessionWindows.has(sid)) sessionWindows.set(sid, winId);     }   } catch {}+  for (const [sid, winId] of [...sessionWindows]) {+    if (!(await windowExists(winId))) {+      sessionWindows.delete(sid);+      if (!_closedSessions.has(sid)) _closedSessions.set(sid, { windowId: winId, byUser: null, ts: Date.now(), external: true });+    }+  }+  await persist(); }  function tabView(t) {@@ -123,36 +137,68 @@ async function assertOwned(tabId, verb) {   } } -// Resolve which tab a verb targets: explicit tabId > active tab of the session.-// opts.requireOwned (set for every MUTATING verb) additionally (a) rejects bare calls instead of-// falling through to the user's active tab, and (b) rejects targets outside agent-owned windows.+// Resolve which tab a verb targets. Keyed off the REAL session→window map, never an "active tab"+// heuristic when a sessionId/tabId is given:+//   explicit tabId   → that tab (ownership re-checked for mutating verbs)+//   explicit sessionId → the active tab of THAT SESSION'S OWN window; if the session isn't tracked+//                        (window closed/re-created externally, or the map was lost while the SW slept)+//                        it THROWS a clear session_untracked/closed error - it NEVER acts on whatever+//                        tab the user happens to be in. (That fallback is the bug this fixes.)+//   bare (neither)   → mutating verbs are refused; only a read-only bare call may use the active tab. async function resolveTabId(args, opts = {}) {   await ensureLoaded();   const verb = opts.verb || 'this verb';-  if (opts.requireOwned) requireTarget(args, verb);-  let tabId;+   if (args && args.tabId != null) {-    tabId = Number(args.tabId);-  } else {-    if (args && args.sessionId != null && !sessionWindows.has(args.sessionId)) {-      const c = _closedSessions.get(args.sessionId);-      if (c) throw new Error(`session '${args.sessionId}' was closed ${c.byUser ? 'BY THE USER' : 'by the agent'} — open a new window with nbrowser_open_window`);+    const tabId = Number(args.tabId);+    await assertDriveableWindow(tabId, args);+    if (opts.requireOwned) await assertOwned(tabId, verb);+    return tabId;+  }++  if (args && args.sessionId != null) {+    const tabId = await tabForSession(args.sessionId, verb); // reconciles; throws if untracked - NEVER active-tab+    await assertDriveableWindow(tabId, args);+    return tabId; // owned by construction: the session→window map is written ONLY by openWindow+  }++  // Bare call - no sessionId, no tabId.+  if (opts.requireOwned) requireTarget(args, verb); // mutating → refuse; never touch the user's tab+  const [tab] = await chrome.tabs.query({ active: true, lastFocusedWindow: true }); // read-only bare only+  if (!tab) throw new Error('no target tab found');+  await assertDriveableWindow(tab.id, args);+  return tab.id;+}++// Resolve the tab for an EXPLICIT session strictly from the session→window map. Reconciles first (so a+// map lost from memory but present in storage is recovered), and if the session's window is truly gone+// it records the close and throws a clear error - it NEVER falls back to the user's active tab.+async function tabForSession(sid, verb) {+  if (!sessionWindows.has(sid)) await reconcile();+  if (sessionWindows.has(sid)) {+    const windowId = sessionWindows.get(sid);+    if (await windowExists(windowId)) {+      let [tab] = await chrome.tabs.query({ active: true, windowId });+      if (!tab) [tab] = await chrome.tabs.query({ windowId }); // OUR window, any tab+      if (tab) return tab.id;     }-    let windowId;-    if (args && args.sessionId != null && sessionWindows.has(args.sessionId)) windowId = sessionWindows.get(args.sessionId);-    const q = windowId != null ? { active: true, windowId } : { active: true, lastFocusedWindow: true };-    const [tab] = await chrome.tabs.query(q);-    if (!tab) throw new Error('no target tab found');-    tabId = tab.id;+    sessionWindows.delete(sid);+    if (!_closedSessions.has(sid)) _closedSessions.set(sid, { windowId, byUser: null, ts: Date.now(), external: true });+    await persist();   }-  await assertDriveableWindow(tabId, args); // ⛔ PWA guard on EVERY resolution path-  if (opts.requireOwned) await assertOwned(tabId, verb);-  return tabId;+  const c = _closedSessions.get(sid);+  throw new GuardError('session_untracked',+    c+      ? `session '${sid}' is closed (${c.byUser === true ? 'by the user' : c.byUser === false ? 'by the agent' : 'its window was closed externally'}) — open a fresh window with nbrowser_open_window. NOT retrying into your active tab.`+      : `session '${sid}' isn't tracked (its window was likely closed/re-created outside the extension). Run nbrowser_resync_sessions to rebuild tracking, then nbrowser_open_window for a fresh window. NOT falling back to your active tab.`,+    OPEN_WINDOW_HINT); } -function resolveWindowId(args) {-  if (args && args.sessionId != null && sessionWindows.has(args.sessionId)) return sessionWindows.get(args.sessionId);-  return null;+// Reconcile-aware window resolve for window-level verbs (open_tab/close_window/switch_window/…).+async function resolveWindowId(args) {+  if (!(args && args.sessionId != null)) return null;+  if (!sessionWindows.has(args.sessionId)) await reconcile();+  return sessionWindows.has(args.sessionId) ? sessionWindows.get(args.sessionId) : null; }  function waitForLoad(tabId, timeoutMs = 30000) {@@ -186,7 +232,7 @@ export async function openWindow(args = {}) {  export async function closeWindow(args = {}) {   await ensureLoaded();-  const winId = resolveWindowId(args);+  const winId = await resolveWindowId(args);   if (winId == null) {     const c = _closedSessions.get(args.sessionId);     throw new Error(c ? `session '${args.sessionId}' was already closed ${c.byUser ? 'by the USER' : 'by the agent'}` : `unknown sessionId '${args.sessionId}'`);@@ -200,7 +246,7 @@ export async function closeWindow(args = {}) {  export async function switchWindow(args = {}) {   await ensureLoaded();-  const winId = resolveWindowId(args);+  const winId = await resolveWindowId(args);   if (winId == null) throw new Error('unknown sessionId');   // BACKGROUND by default — switching which window the agent targets must NEVER raise it into the   // user's face. Every verb already targets a window by its sessionId, so this is a no-op for@@ -215,7 +261,7 @@ export async function switchWindow(args = {}) { // intercepts browser-chrome shortcuts before the page ever sees the CDP key event). export async function windowState(args = {}) {   await ensureLoaded();-  const winId = resolveWindowId(args);+  const winId = await resolveWindowId(args);   if (winId == null) throw new Error('unknown sessionId');   // Move/resize path — any of left/top/width/height present. chrome.windows requires the   // window be in 'normal' state before bounds take, so force it first.@@ -255,16 +301,31 @@ export async function listWindows() {  // reconcile the session map against live windows (drop closed ones) export async function rescan() {-  await ensureLoaded();-  for (const [sid, winId] of [...sessionWindows]) if (!(await windowExists(winId))) sessionWindows.delete(sid);-  await persist();+  await reconcile();   return listWindows(); } +// nbrowser_resync_sessions — LIGHTWEIGHT rebuild of session tracking WITHOUT a full dev_reload. Re-reads+// the persisted map, merges it into memory, and re-validates every session against live windows (gone+// windows → marked closed). Use it when session verbs start failing with session_untracked after the+// user interacted with Chrome or another tool moved/closed windows - it un-sticks tracking in one call.+export async function resyncSessions() {+  loaded = false;              // force a fresh read from storage+  await ensureLoaded();+  const tracked = [...sessionWindows].map(([sessionId, windowId]) => ({ sessionId, windowId }));+  const closed = [...(_closedSessions.entries())].map(([sessionId, c]) => ({ sessionId, byUser: c.byUser, external: !!c.external }));+  return {+    ok: true, tracked, trackedCount: tracked.length, closed,+    _hint: tracked.length+      ? `Session tracking rebuilt: ${tracked.length} live agent window(s) are drivable by their sessionId. Closed/untracked sessions are listed under "closed" - open fresh windows for those with nbrowser_open_window.`+      : 'No live agent windows are tracked. Open one with nbrowser_open_window (it auto-pins its sessionId).',+  };+}+ // ---- tabs ------------------------------------------------------------------ export async function openTab(args = {}) {   await ensureLoaded();-  const windowId = resolveWindowId(args);+  const windowId = await resolveWindowId(args);   if (windowId == null) {     throw new GuardError('no_target',       "\u26d4 no_target: nbrowser_open_tab without the sessionId of a window YOU opened would drop a tab into the USER'S OWN window \u2014 refused.",@@ -291,7 +352,7 @@ export async function switchTab(args = {}) {  export async function listTabs(args = {}) {   await ensureLoaded();-  const windowId = resolveWindowId(args);+  const windowId = await resolveWindowId(args);   const tabs = await chrome.tabs.query(windowId != null ? { windowId } : {});   const active = tabs.find((t) => t.active);   return { ok: true, count: tabs.length, activeTabId: active ? String(active.id) : null, tabs: tabs.map(tabView) };