@agent360/browser-mcp 1.24.0 → 1.28.1

package/extension/background.js

@@ -36,12 +36,25 @@ function restoreSessions() {
       }
       if (validTabIds.size > 0) {
         const activeTabId = data.activeTabId && validTabIds.has(data.activeTabId) ? data.activeTabId : null;
+        // Samme kollisionsfejl som i getSession, og derfor samme rettelse: `size + 1`
+        // genbruger et nummer der allerede er i brug. Her betyder det at to gendannede
+        // sessioner kan komme op med samme navn efter en genstart af service-workeren.
+        const brugte = new Set([...sessions.values()].map((x) => x.nummer).filter((n) => typeof n === 'number'));
+        let nummer = typeof data.nummer === 'number' ? data.nummer : 1;
+        while (brugte.has(nummer)) nummer++;
         sessions.set(Number(port), {
           tabIds: validTabIds,
           activeTabId,
           groupId: data.groupId || null,
-          color: data.color || SESSION_COLORS[sessions.size % SESSION_COLORS.length],
-          label: data.label || `Claude ${sessions.size + 1}`,
+          nummer,
+          // MAALT 22/8: her stod `data.color || …` og `data.label || …`. Bumpede
+          // kollisionsloekken nummeret, fulgte navn og farve IKKE med — de blev
+          // gendannet ordret fra lageret. To sessioner kunne saa have hvert sit
+          // nummer og stadig begge hedde "Claude 1" i samme farve. Og navnet er
+          // praecis dét brugeren ser paa fanegruppen.
+          color: SESSION_COLORS[(nummer - 1) % SESSION_COLORS.length],
+          label: `Claude ${nummer}`,
+          pid: typeof data.pid === 'number' ? data.pid : null,
         });
       }
     }
@@ -49,18 +62,114 @@ function restoreSessions() {
   return restorePromise;
 }
 
-function getSession(port) {
+function getSession(port, pid) {
   if (!sessions.has(port)) {
-    const idx = sessions.size % SESSION_COLORS.length;
+    // ── Hvorfor det laveste LEDIGE nummer, og ikke sessions.size + 1 (MAALT 22/8) ──
+    // Med `size + 1` genbruges et nummer der allerede er i brug, saa snart en chat
+    // lukker: tre chats hedder 1, 2, 3 · chat 1 lukker · size er nu 2 · naeste chat
+    // faar "Claude 3" — som chat 3 stadig hedder. To chats deler navn OG farve, og
+    // brugeren kan ikke se hvilken fanegruppe der hoerer til hvad.
+    //
+    // Det er en TREDJE mekanisme bag "alt hedder Claude 1", uafhaengig af de to andre
+    // (to udvidelser om samme socket, og adoption uden live-port-gate). Den her
+    // rammer ogsaa naar alt andet er rigtigt — man skal bare lukke en chat.
+    //
+    // Laveste ledige nummer genbruger frigivne pladser uden at kollidere, saa numrene
+    // bliver ved med at vaere smaa og laesbare. Farven foelger nummeret, saa to
+    // samtidige sessioner heller ikke kan faa samme farve.
+    const brugte = new Set([...sessions.values()].map((s) => s.nummer).filter((n) => typeof n === 'number'));
+    let nummer = 1;
+    while (brugte.has(nummer)) nummer++;
+
     sessions.set(port, {
       tabIds: new Set(),
       activeTabId: null,
       groupId: null,
-      color: SESSION_COLORS[idx],
-      label: `Claude ${sessions.size + 1}`,
+      nummer,
+      color: SESSION_COLORS[(nummer - 1) % SESSION_COLORS.length],
+      label: `Claude ${nummer}`,
+      pid: typeof pid === 'number' ? pid : null,
     });
   }
-  return sessions.get(port);
+  const s = sessions.get(port);
+  // Foerste kald fra en genstartet server kan baere pid'en foer sessionen har den.
+  if (s.pid == null && typeof pid === 'number') s.pid = pid;
+  return s;
+}
+
+// Adopt tabs from a session whose MCP connection is gone (FIX-18: reconnect orphaning).
+//
+// Sessions are keyed on the MCP port. A clean shutdown sends session_disconnect and the
+// tabs are closed. But an UNCLEAN drop (server restart, network blip, laptop sleep) leaves
+// the session in storage while the client reconnects on a NEW port — so getSession() hands
+// back an empty session. Observed damage: navigate() returns tab X while click() fails on
+// tab Y, list_tabs() comes back empty, a fresh about:blank spawns per call, and the session
+// label walks Claude 1 → 2 → 3 → 4. Every navigate→click pair breaks.
+//
+// Fix: before serving an unknown port, hand over the tabs of the largest session whose port
+// is no longer in mcpPorts (the live-connection list the offscreen bridge keeps in storage).
+// Keeps label/color so the user sees continuity instead of a renumbered session.
+async function adoptOrphanedSession(port, pid) {
+  // Only ever fires for a session that OWNS NOTHING — a session with tabs is left alone.
+  if (sessions.has(port) && sessions.get(port).tabIds.size) return null;
+
+  // ── Hvorfor pid'en er afgoerende (regression fundet 16/8) ────────────────────
+  // Den oprindelige version adopterede den STOERSTE session uanset hvem den tilhoerte,
+  // med den begrundelse at Claude Code spreder kald over flere forbindelser. Men en
+  // helt NY chat ejer ogsaa ingenting — saa hver ny chat stjal den aktive chats faner
+  // OG dens identitet (linje: sessions.delete(best.port)). Donorens port forsvandt fra
+  // kortet, saa dens naeste kald adopterede tilbage. To chats byttede den samme ene
+  // session frem og tilbage: alt hed "Claude 1", og kun én ting kunne koere ad gangen.
+  //
+  // Det aegte behov er smallere: naar EN chats MCP-server genstarter, faar den en ny
+  // port og skal genfinde sine egne faner. Den situation kan skelnes praecist, fordi
+  // begge porte hoerer til den samme Claude Code-proces. Derfor: adoptér kun fra en
+  // session med samme pid. Mangler pid'en (gammel server mod ny udvidelse), adopteres
+  // slet ikke — hellere en frisk session end en stjaalet.
+  if (typeof pid !== 'number') return null;
+
+  // ── Anden halvdel af gaten (MAALT 21/8) ─────────────────────────────────────
+  // Pid'en alene raekker ikke. Foraelder-processen er IKKE en unik identitet: starter
+  // en klient flere MCP-servere fra den samme proces, har de alle samme pid — og saa
+  // adopterede de hinandens faner paa stribe. Maalt med fire samtidige sessioner:
+  // alle fik navnet "Claude 3", de tre aeldste mistede deres fane, og en session
+  // kunne skifte til en andens. Altsaa "alt hedder Claude 1", i sin rene form, med
+  // kun én udvidelse indlaest.
+  //
+  // Det manglende tjek staar allerede beskrevet oeverst i denne funktion: adoptér kun
+  // fra en session hvis port IKKE laengere er forbundet. Er donorens port stadig i
+  // live, er det en anden chat der arbejder lige nu — ikke en genstartet server.
+  // Listen vedligeholdes af broen (ws_status → mcpPorts) ved hver til- og frakobling.
+  const { mcpPorts = [] } = await chrome.storage.local.get({ mcpPorts: [] });
+  const levendePorte = new Set(mcpPorts.map(Number));
+
+  let best = null;
+  for (const [p, session] of sessions) {
+    if (p === port || !session.tabIds.size) continue;
+    if (session.pid !== pid) continue;        // en anden chat — lad den vaere
+    if (levendePorte.has(Number(p))) continue; // donoren arbejder stadig — hænderne væk
+    if (!best || session.tabIds.size > best.session.tabIds.size) best = { port: p, session };
+  }
+  if (!best) return null;
+
+  // Verify at least one tab survives — an orphan whose tabs the user already closed is
+  // worthless, and adopting it would mask a genuinely fresh start.
+  const alive = new Set();
+  for (const tabId of best.session.tabIds) {
+    try { await chrome.tabs.get(tabId); alive.add(tabId); } catch {}
+  }
+  if (!alive.size) {
+    sessions.delete(best.port);
+    persistSessions();
+    return null;
+  }
+
+  best.session.tabIds = alive;
+  if (!alive.has(best.session.activeTabId)) best.session.activeTabId = null;
+  sessions.delete(best.port);
+  sessions.set(port, best.session);
+  persistSessions();
+  return best.session;
 }
 
 // LRU eviction cap: hver session må højst have N åbne tabs samtidigt.
@@ -69,7 +178,13 @@ function getSession(port) {
 // Begrundelse: Claude Code-flows kan åbne 20+ navigate(new_tab=true) per session
 // over en længere conversation. Uden eviction akkumulerer disse i Chrome som
 // orphan-tabs der spiser RAM + giver "extension localhost 19+" tab-noise.
-const MAX_TABS_PER_SESSION = 10;
+//
+// Hævet 10 → 20 (21/8). Ti var for lavt til reelle flows: en jagt der åbner en
+// fane pr. udbyder ramte loftet midtvejs, og evictionen lukkede de faner arbejdet
+// stadig byggede på — tavst, for eviction rapporterer ikke noget. Tyve matcher
+// portspændet (9876-9895), så en session kan holde lige så mange faner som der
+// kan køre samtidige sessioner.
+const MAX_TABS_PER_SESSION = 20;
 
 async function evictOldestTabs(session, justAddedTabId) {
   // Drop dead tab-ids først (user manually closed dem)
@@ -154,6 +269,8 @@ function persistSessions() {
       groupId: session.groupId,
       color: session.color,
       label: session.label,
+      nummer: session.nummer ?? null,   // uden denne mister en gendannet session sin plads og kan kollidere
+      pid: session.pid ?? null,   // uden denne adopterer en genstartet service worker paa tvaers af chats igen
     };
   }
   chrome.storage.local.set({ sessions: data });
@@ -384,12 +501,49 @@ async function cdpSend(tabId, method, params = {}) {
 }
 
 // Clean up debugger + session refs when tabs close
+// Faner agenten selv lukkede via close_tab. En tom session betyder kun "arbejdet er slut"
+// hvis det var BRUGEREN der lukkede den sidste fane.
+const agentLukkedeFaner = new Set();
+
+// ── Armerede dialog-haandterere, pr. fane ──────────────────────────────────────
+// MAALT 22/8 af flowtesten: handle_dialog var ubrugelig som den var skrevet. Den
+// BLOKEREDE i op til 10 sekunder mens den ventede paa en dialog — men en alert(),
+// confirm() eller prompt() dukker foerst op naar man klikker paa noget, og klikket
+// kan ikke ske mens kaldet blokerer. Man kunne altsaa hverken arme den foerst eller
+// kalde den bagefter: naar dialogen foerst staar der, er hele fanen laast, og
+// klik-vaerktoejet naar ikke frem. Vaerktoejet kunne kun lykkes hvis en ANDEN aabnede
+// dialogen paa praecis det rigtige tidspunkt.
+//
+// Nu armerer den og vender tilbage med det samme. Lytteren bliver siddende og tager
+// den naeste dialog paa fanen. `wait: true` giver den gamle blokerende adfaerd for
+// de tilfaelde hvor dialogen allerede er undervejs.
+const armeredeDialoger = new Map();
+// Loeftet for den senest armerede dialog pr. fane. Ligger UDEN for armeredeDialoger,
+// fordi lytteren afvaebner i samme oejeblik dialogen aabner — og klikket skal kunne
+// vente paa svaret BAGEFTER.
+const dialogLoefter = new Map();   // tabId -> Promise   // tabId → { listener, timer, action }
+
+function afvaebnDialog(tabId, grund) {
+  const a = armeredeDialoger.get(tabId);
+  if (!a) return;
+  try { chrome.debugger.onEvent.removeListener(a.listener); } catch {}
+  clearTimeout(a.timer);
+  armeredeDialoger.delete(tabId);
+  // MAALT 22/8: her stoppede funktionen. Loeftet blev ALDRIG opfyldt, saa en kalder
+  // med `wait: true` haengte for evigt ad to helt almindelige veje — fanen blev
+  // lukket, eller et andet handle_dialog armerede paa samme fane. Ingen fejl, intet
+  // svar, bare stilhed. Nu faar kalderen altid et svar.
+  if (grund && a.opfyld) a.opfyld({ ok: false, error: grund });
+}
+
 chrome.tabs.onRemoved.addListener((tabId) => {
+  afvaebnDialog(tabId, 'fanen blev lukket foer der kom en dialog');
+  const lukketAfAgenten = agentLukkedeFaner.delete(tabId);
   debuggerAttached.delete(tabId);
   for (const [port, session] of sessions) {
     if (!session.tabIds.has(tabId)) continue;
     session.tabIds.delete(tabId);
-    if (session.tabIds.size === 0) {
+    if (session.tabIds.size === 0 && !lukketAfAgenten) {
       // Last tab closed — tell offscreen to terminate the MCP server.
       // Resulting WS-close triggers the existing session_disconnect → releaseSession path.
       chrome.runtime.sendMessage({ type: 'terminate_mcp_session', port }).catch(() => {});
@@ -399,34 +553,112 @@ chrome.tabs.onRemoved.addListener((tabId) => {
   }
 });
 
+// Physical-key `code` for a character, US layout. We used to build this as
+// `Key${char.toUpperCase()}`, which is only correct for letters: "1" became "Key1",
+// "@" became "Key@", " " became "Key ". Frameworks that branch on event.code —
+// masked inputs, shortcut handlers, several React form libraries — see an unknown
+// code and drop the keystroke, so typing an email or URL misbehaved on strict SPAs.
+// Shifted symbols report the code of the physical key they sit on ("@" is Digit2).
+const CDP_CHAR_CODES = {
+  ' ': 'Space', '\n': 'Enter', '\t': 'Tab',
+  '-': 'Minus', '_': 'Minus', '=': 'Equal', '+': 'Equal',
+  '[': 'BracketLeft', '{': 'BracketLeft', ']': 'BracketRight', '}': 'BracketRight',
+  '\\': 'Backslash', '|': 'Backslash', ';': 'Semicolon', ':': 'Semicolon',
+  "'": 'Quote', '"': 'Quote', ',': 'Comma', '<': 'Comma',
+  '.': 'Period', '>': 'Period', '/': 'Slash', '?': 'Slash',
+  '`': 'Backquote', '~': 'Backquote',
+  '!': 'Digit1', '@': 'Digit2', '#': 'Digit3', '$': 'Digit4', '%': 'Digit5',
+  '^': 'Digit6', '&': 'Digit7', '*': 'Digit8', '(': 'Digit9', ')': 'Digit0',
+};
+function cdpCodeForChar(ch) {
+  if (ch >= 'a' && ch <= 'z') return `Key${ch.toUpperCase()}`;
+  if (ch >= 'A' && ch <= 'Z') return `Key${ch}`;
+  if (ch >= '0' && ch <= '9') return `Digit${ch}`;
+  // Unknown (accented letters, CJK, emoji): omit it. CDP accepts a missing code,
+  // and an omitted code is honest where a fabricated one is actively misleading.
+  return CDP_CHAR_CODES[ch] || '';
+}
+
+// Types text as individual key events. Assumes the debugger is already attached —
+// debuggerType() is the public wrapper that manages attach/detach.
+async function typeCharsAttached(tabId, text) {
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const code = cdpCodeForChar(char);
+    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
+      type: 'keyDown',
+      text: char,
+      key: char,
+      ...(code ? { code } : {}),
+      unmodifiedText: char,
+    });
+    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
+      type: 'keyUp',
+      key: char,
+      ...(code ? { code } : {}),
+    });
+    // Human-like typing: random 30-120ms, occasional longer pause
+    const pause = (i > 0 && i % (7 + Math.floor(Math.random() * 5)) === 0)
+      ? 150 + Math.random() * 200  // thinking pause every ~10 chars
+      : 30 + Math.random() * 90;   // normal keystroke
+    await new Promise(r => setTimeout(r, pause));
+  }
+}
+
 async function debuggerType(tabId, text) {
   await debuggerAttach(tabId);
   try {
-    for (let i = 0; i < text.length; i++) {
-      const char = text[i];
-      await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-        type: 'keyDown',
-        text: char,
-        key: char,
-        code: `Key${char.toUpperCase()}`,
-        unmodifiedText: char,
-      });
-      await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-        type: 'keyUp',
-        key: char,
-        code: `Key${char.toUpperCase()}`,
-      });
-      // Human-like typing: random 30-120ms, occasional longer pause
-      const pause = (i > 0 && i % (7 + Math.floor(Math.random() * 5)) === 0)
-        ? 150 + Math.random() * 200  // thinking pause every ~10 chars
-        : 30 + Math.random() * 90;   // normal keystroke
-      await new Promise(r => setTimeout(r, pause));
-    }
+    await typeCharsAttached(tabId, text);
   } finally {
     await debuggerDetach(tabId);
   }
 }
 
+// ── Naar en dialog kan aabne midt i klikket (MAALT 24/8) ─────────────────────
+//
+// Et confirm() fryser rendereren, og Chrome svarer ALDRIG paa den CDP-kommando der
+// udloeste det. Maalt: browser_click haengte i 25,9 sekunder og gav aldrig svar —
+// mens dialogen faktisk BLEV besvaret af den armerede haandtering (siden rapporterede
+// window.__svar === true). Klikket var altsaa leveret; kun svaret var vaek.
+//
+// Er der armeret en dialog paa fanen, venter vi derfor kun kort. Kommer der intet
+// svar, ER klikket leveret — det er jo netop dét der aabnede dialogen.
+async function dispatchTaalmodigt(tabId, params) {
+  if (!armeredeDialoger.has(tabId)) {
+    return cdpSend(tabId, 'Input.dispatchMouseEvent', params);
+  }
+  let faerdig = false;
+  const kald = cdpSend(tabId, 'Input.dispatchMouseEvent', params)
+    .then((r) => { faerdig = true; return r; })
+    .catch(() => { faerdig = true; });
+  await Promise.race([kald, new Promise((r) => setTimeout(r, 1200))]);
+  return faerdig ? kald : { __dialogBlokerede: true };
+}
+
+// MAALT 28/8: `dispatchTaalmodigt` ovenfor lukkede deadlocken paa museklikket, men
+// settle-opslaget i step 3 er OGSAA et renderer-kald — og maalingen viste at det er
+// PRAECIS der klikket haenger (HAENGER@step3-settle). Deadlocken var kun lukket paa
+// hovedstien.
+//
+// Foerste forsoeg gjorde kuren betinget af at vi kunne SE en dialog (armeret, eller en
+// dispatch der blokerede). Den betingelse holder ikke: dispatchen kan naa at blive
+// kvitteret, og lytteren kan naa at afvaebne, FOER rendereren gaar i staa. Saa faldt vi
+// tilbage i det ubeskyttede kald og hang alligevel — maalt.
+//
+// Derfor er fristen nu betingelsesloes. Opslaget er et par linjers synkron JS: svarer
+// rendereren, er den tilbage paa millisekunder. Bruger den over tre sekunder, er den
+// blokeret — ikke langsom. Saa svarer vi aerligt i stedet for at vente i 30.
+// Et klik der aabnede en dialog ER landet, saa framework-fallbacken skal ikke fyre oveni.
+async function evaluerTaalmodigt(tabId, params, ms = 3000) {
+  let faerdig = false;
+  const kald = cdpSend(tabId, 'Runtime.evaluate', params)
+    .then((r) => { faerdig = true; return r; })
+    .catch(() => { faerdig = true; });
+  await Promise.race([kald, new Promise((r) => setTimeout(r, ms))]);
+  if (faerdig) return kald;
+  return { result: { value: { landed: true, fallbackFired: false, rendererSvarede: false } } };
+}
+
 async function debuggerClick(tabId, x, y) {
   await debuggerAttach(tabId);
   try {
@@ -464,7 +696,7 @@ async function debuggerClick(tabId, x, y) {
       })()`,
     });
     // 1. mouseMoved first (triggers hover state, required by some frameworks)
-    await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+    await dispatchTaalmodigt(tabId, {
       type: 'mouseMoved', x, y,
     });
     await new Promise(r => setTimeout(r, 30));
@@ -472,11 +704,11 @@ async function debuggerClick(tabId, x, y) {
     //    0 on release) plus a small press→release gap are REQUIRED for Chrome to
     //    synthesize a *trusted* 'click' from the pair. Without them, web-components
     //    that gate on the trusted click event (Google Ads, Material Web) never fire.
-    await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+    await dispatchTaalmodigt(tabId, {
       type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 1,
     });
     await new Promise(r => setTimeout(r, 30));
-    await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+    await dispatchTaalmodigt(tabId, {
       type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 1,
     });
     // 3. Framework fallback — only if the captured target is STILL connected (i.e.
@@ -484,14 +716,15 @@ async function debuggerClick(tabId, x, y) {
     //    SPA re-renders (Google Ads) detach the element first. Fires a full pointer
     //    + mouse sequence on the shadow-pierced target, then React/Angular handlers.
     await new Promise(r => setTimeout(r, 120));
-    await cdpSend(tabId, 'Runtime.evaluate', {
+    const settle = await evaluerTaalmodigt(tabId, {
+      returnByValue: true,
       expression: `(() => {
         const el = window.__bmcpClickTarget;
         const landed = window.__bmcpClicked === true;
         try { window.__bmcpClickListener && document.removeEventListener('click', window.__bmcpClickListener, true); } catch (e) {}
         try { delete window.__bmcpClickTarget; delete window.__bmcpClicked; delete window.__bmcpClickListener; } catch (e) {}
-        if (landed) return;                   // FIX-13: trusted click already landed — do NOT double-fire
-        if (!el || !el.isConnected) return;   // already navigated/handled — don't double-fire
+        if (landed) return { landed: true, fallbackFired: false };   // FIX-13: trusted click already landed — do NOT double-fire
+        if (!el || !el.isConnected) return { landed: false, fallbackFired: false, detached: true };   // already navigated/handled — don't double-fire
         const opts = { bubbles: true, cancelable: true, composed: true, view: window, clientX: ${x}, clientY: ${y} };
         try { el.dispatchEvent(new PointerEvent('pointerdown', opts)); } catch (e) {}
         el.dispatchEvent(new MouseEvent('mousedown', opts));
@@ -516,8 +749,24 @@ async function debuggerClick(tabId, x, y) {
           const matRipple = el.closest && el.closest('[mat-button], [mat-raised-button], [mat-icon-button], [mat-fab], mat-checkbox, mat-slide-toggle, mat-radio-button');
           if (matRipple) matRipple.dispatchEvent(new MouseEvent('click', opts));
         }
+        return { landed: false, fallbackFired: true };
       })()`,
     });
+    const vaerdi = settle?.result?.value ?? null;
+
+    // MAALT 28/8: uden det her svarede klikket 5,5 sek FOER dialogen var besvaret, saa
+    // den NAESTE kommando ramte en stadig frossen side og ventede 15 sek forgaeves.
+    // Svarede rendereren ikke, ER der en dialog i vejen — saa vent til den er ude af
+    // verden, foer vi melder klikket faerdigt. Sidebonus: kalderen faar en side der
+    // rent faktisk er klar til naeste skridt.
+    if (vaerdi && vaerdi.rendererSvarede === false) {
+      const loefte = dialogLoefter.get(tabId);
+      if (loefte) {
+        await Promise.race([loefte, new Promise((r) => setTimeout(r, 8000))]);
+        dialogLoefter.delete(tabId);
+      }
+    }
+    return vaerdi;
   } finally {
     await debuggerDetach(tabId);
   }
@@ -539,6 +788,32 @@ async function debuggerFocus(tabId, selector) {
   }
 }
 
+// Runtime.evaluate that leaves attach state alone. debuggerEval() detaches in its
+// finally, which would pull the debugger out from under a fill that is mid-flight.
+async function evalAttached(tabId, expression) {
+  const result = await cdpSend(tabId, 'Runtime.evaluate', { expression, returnByValue: true });
+  if (result.exceptionDetails) {
+    throw new Error(result.exceptionDetails.text || 'Script execution failed');
+  }
+  return result.result?.value;
+}
+
+// Select-all + Backspace. Assumes the debugger is already attached.
+async function clearFieldAttached(tabId) {
+  await cdpSend(tabId, 'Input.dispatchKeyEvent', {
+    type: 'keyDown', key: 'a', code: 'KeyA', modifiers: SELECT_ALL_MODS,
+  });
+  await cdpSend(tabId, 'Input.dispatchKeyEvent', {
+    type: 'keyUp', key: 'a', code: 'KeyA',
+  });
+  await cdpSend(tabId, 'Input.dispatchKeyEvent', {
+    type: 'keyDown', key: 'Backspace', code: 'Backspace',
+  });
+  await cdpSend(tabId, 'Input.dispatchKeyEvent', {
+    type: 'keyUp', key: 'Backspace', code: 'Backspace',
+  });
+}
+
 async function debuggerFill(tabId, selector, value) {
   // Check if element is contenteditable (rich text editors: LinkedIn, Slack)
   const isContentEditable = await debuggerEval(tabId, `
@@ -566,27 +841,39 @@ async function debuggerFill(tabId, selector, value) {
     return;
   }
 
-  // Standard input/textarea — focus, clear, type
+  // Standard input/textarea — focus, clear, fill
   await debuggerFocus(tabId, selector);
   await debuggerAttach(tabId);
   try {
-    // Select-all (Cmd+A on macOS, Ctrl+A elsewhere), then Backspace to clear
-    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-      type: 'keyDown', key: 'a', code: 'KeyA', modifiers: SELECT_ALL_MODS,
-    });
-    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-      type: 'keyUp', key: 'a', code: 'KeyA',
-    });
-    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-      type: 'keyDown', key: 'Backspace', code: 'Backspace',
-    });
-    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-      type: 'keyUp', key: 'Backspace', code: 'Backspace',
-    });
+    await clearFieldAttached(tabId);
+
+    // Fast path: one trusted InputEvent instead of N key events. This is the same
+    // primitive set_combobox and set_date already rely on, it avoids per-key `code`
+    // mapping entirely, and it turns a 40-character value from ~3 seconds of
+    // keystrokes into a single call — which also shrinks the window in which the
+    // debugger can detach mid-fill.
+    await cdpSend(tabId, 'Input.insertText', { text: value });
+
+    // Verify something actually landed. Masked inputs, maxlength enforcement and
+    // autocompletes that filter per keydown can swallow an inserted string, and
+    // until now that failed silently: the caller got "ok" and the field stayed
+    // empty. Only an EMPTY field triggers the fallback — a field that transformed
+    // the text (phone/date masks reformatting it) did accept the input, and
+    // retyping it per character would produce the same transform for no gain.
+    const landed = await evalAttached(tabId, `
+      (function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return null;
+        return ('value' in el) ? el.value : el.textContent;
+      })()
+    `);
+    if (!landed) {
+      await clearFieldAttached(tabId);
+      await typeCharsAttached(tabId, value);
+    }
   } finally {
     await debuggerDetach(tabId);
   }
-  await debuggerType(tabId, value);
 }
 
 async function debuggerEval(tabId, expression) {
@@ -758,6 +1045,13 @@ async function resolveElement(tabId, selectorStr) {
       if (!el) return null;
       el.scrollIntoView({ block: 'center', behavior: 'instant' });
       const r = el.getBoundingClientRect();
+      // MAALT 21/8: et skjult element har rect 0x0 ved (0,0), saa midtpunktet blev (0,0)
+      // og debuggerClick sendte et AEGTE museklik i sidens oeverste venstre hjoerne —
+      // paa hvad der nu laa der (logo, menu, link) — og svarede ok:true. Det er ikke en
+      // rapporteringsfejl men en handlingsfejl: vi klikker et andet sted end der blev bedt om.
+      if (r.width <= 0 || r.height <= 0) {
+        return { found: false, hidden: true, tag: el.tagName, rect: { w: r.width, h: r.height } };
+      }
       return { x: r.x + r.width / 2, y: r.y + r.height / 2, tag: el.tagName, found: true };
     };
 
@@ -779,6 +1073,9 @@ async function resolveElement(tabId, selectorStr) {
           if (!el) return null;
           el.scrollIntoView({ block: 'center', behavior: 'instant' });
           const r = el.getBoundingClientRect();
+          if (r.width <= 0 || r.height <= 0) {
+            return { found: false, hidden: true, tag: el.tagName, rect: { w: r.width, h: r.height } };
+          }
           return { x: r.x + r.width/2, y: r.y + r.height/2, tag: el.tagName, found: true };
         })()
       `);
@@ -795,6 +1092,9 @@ async function resolveElement(tabId, selectorStr) {
       if (!el) return null;
       el.scrollIntoView({ block: 'center', behavior: 'instant' });
       const r = el.getBoundingClientRect();
+      if (r.width <= 0 || r.height <= 0) {
+        return { found: false, hidden: true, tag: el.tagName, text: el.textContent?.trim().slice(0, 80), rect: { w: r.width, h: r.height } };
+      }
       return { x: r.x + r.width/2, y: r.y + r.height/2, tag: el.tagName, text: el.textContent?.trim().slice(0, 80), found: true };
     })()
   `);
@@ -803,15 +1103,121 @@ async function resolveElement(tabId, selectorStr) {
 
 // ── Offscreen Document Setup ───────────────────────────────────────────────
 
+// MAALT 21/8: her stod kun `if (!await chrome.offscreen.hasDocument()) createDocument()`.
+// Den spurgte om dokumentet FANDTES — aldrig om det SVAREDE. Et dokument hvis script
+// aldrig blev indlaest (en CSP-afvisning raekker) taeller stadig som eksisterende, saa
+// hjerteslaget hvert minut gjorde ingenting, for evigt. Udvidelsen saa levende ud i
+// chrome://extensions, men havde ingen WebSocket og kunne ikke naas af noget — heller
+// ikke af reload_extension, som netop kraever den forbindelse den mangler. Eneste vej
+// ud var ↻ i haanden.
+//
+// Nu spoerges dokumentet om det er der. Svarer det ikke, erstattes det.
+async function offscreenSvarer() {
+  try {
+    const svar = await Promise.race([
+      chrome.runtime.sendMessage({ type: 'bmcp_ping' }),
+      new Promise((_, afvis) => setTimeout(() => afvis(new Error('intet svar')), 1500)),
+    ]);
+    if (svar?.ok !== true) return false;
+    // "Svarer den?" er ikke nok — den skal ogsaa vaere den udgave vi koerer nu.
+    // En bro fra en aeldre udgave svarer lige saa villigt, og saa blev den aldrig
+    // udskiftet. Oplyser den ingen version, er den fra foer 1.27.1 og altsaa gammel.
+    let vores = null;
+    try { vores = chrome.runtime.getManifest().version; } catch {}
+    if (!vores) return true;                       // kan vi ikke sammenligne, saa lad den vaere
+    return svar.version === vores;
+  } catch {
+    return false;   // ingen modtager, eller den svarede ikke i tide
+  }
+}
+
+// Genskabelsen er BEGRAENSET, og det er ikke pynt.
+//
+// "Svarer ikke" betyder ikke altid "doed". En AELDRE offscreen.js — fra foer
+// ping-lytteren fandtes — svarer heller ikke, og Chrome kan servere den fra cache
+// hen over en genindlaesning (maalt 21/8). Uden en graense ville hjerteslaget saa
+// lukke og genskabe en fuldt fungerende bro hvert minut, for evigt, og rive
+// WebSocket-forbindelsen ned hver gang. Kuren ville vaere vaerre end sygdommen.
+//
+// Derfor: hoejst tre forsoeg i traek. Er dokumentet aegte doedt, er ét nok. Er det
+// bare gammelt, koster det tre korte afbrydelser og saa faar det fred et stykke tid.
+//
+// MAALT 22/8 — og det var en fejl i denne blok: graensen var PERMANENT. Naaede
+// taelleren tre, blev der aldrig forsoegt igen, og taelleren nulstilles kun naar en
+// ping lykkes — hvilket en doed bro pr. definition aldrig goer. Resultatet var en
+// doed bro der laa doed for evigt, hvor symptomet for brugeren er "browser-mcp
+// virker ikke", og hvor den eneste udvej var at genindlaese udvidelsen i haanden.
+// Praecis den tilstand vaernet skulle forhindre.
+//
+// Rettelsen: graensen er nu tidsbestemt, ikke endelig. Efter tre forsoeg holder vi
+// pause — og naar pausen er ovre, proever vi igen. En gammel-men-fungerende bro
+// faar altsaa ro i pausen i stedet for at blive revet ned hvert minut, og en aegte
+// doed bro er hoejst én pause fra at blive erstattet. Begge hensyn er i behold.
+const MAX_OFFSCREEN_GENSKAB = 3;
+const OFFSCREEN_PAUSE_MS = 10 * 60 * 1000;
+
 async function ensureOffscreen() {
-  const existing = await chrome.offscreen.hasDocument();
-  if (!existing) {
-    await chrome.offscreen.createDocument({
-      url: 'offscreen.html',
-      reasons: ['WORKERS'],
-      justification: 'Maintain persistent WebSocket connection to local MCP server',
-    });
+  const findes = await chrome.offscreen.hasDocument();
+
+  if (findes) {
+    if (await offscreenSvarer()) {
+      await chrome.storage.local.set({ offscreenGenskabt: 0 });   // levende — nulstil
+      return;
+    }
+    // Taelleren skal ligge i storage, ikke i en modul-variabel: service-workeren
+    // genstartes hele tiden, og en variabel ville nulstilles ved hver genstart —
+    // altsaa ingen graense i praksis.
+    let { offscreenGenskabt = 0 } =
+      await chrome.storage.local.get({ offscreenGenskabt: 0, offscreenPauseTil: 0 });
+    const { offscreenPauseTil = 0 } =
+      await chrome.storage.local.get({ offscreenPauseTil: 0 });
+
+    const nu = Date.now();
+    if (offscreenPauseTil > nu) return;            // midt i pausen — lad broen vaere
+
+    if (offscreenPauseTil > 0) {
+      // Pausen er udloebet. Taelleren SKAL nulstilles her, foer graensen tjekkes —
+      // ellers rammer vi graensen igen med det samme, saetter endnu en pause, og
+      // graensen er i praksis permanent alligevel, bare med et ekstra skridt.
+      // (Maalt 22/8: det var praecis den fejl den foerste udgave af rettelsen havde.
+      // Testen "naar pausen er ovre, proeves der igen" fangede den.)
+      offscreenGenskabt = 0;
+      await chrome.storage.local.set({ offscreenGenskabt: 0, offscreenPauseTil: 0 });
+    }
+
+    if (offscreenGenskabt >= MAX_OFFSCREEN_GENSKAB) {
+      // Pause i stedet for at give op. Taelleren nulstilles samtidig, saa naeste
+      // runde faar sine egne tre forsoeg — ellers ville graensen vaere permanent
+      // alligevel, bare med et ekstra skridt.
+      console.warn(`[BG] offscreen-dokumentet svarer stadig ikke efter ${MAX_OFFSCREEN_GENSKAB} ` +
+        `forsoeg — holder pause i ${OFFSCREEN_PAUSE_MS / 60000} min og proever saa igen. ` +
+        'Haster det: chrome://extensions → slaa udvidelsen fra og til.');
+      await chrome.storage.local.set({ offscreenGenskabt: 0, offscreenPauseTil: nu + OFFSCREEN_PAUSE_MS });
+      return;
+    }
+    console.warn(`[BG] offscreen-dokumentet svarer ikke — erstatter det (forsoeg ${offscreenGenskabt + 1}/${MAX_OFFSCREEN_GENSKAB})`);
+    await chrome.storage.local.set({ offscreenGenskabt: offscreenGenskabt + 1 });
+    try { await chrome.offscreen.closeDocument(); } catch (e) {
+      console.warn('[BG] kunne ikke lukke det doede dokument:', e?.message || e);
+      return;                                      // proev igen ved naeste hjerteslag
+    }
   }
+
+  // Versionen foelger med i URL'en. Et offscreen-dokument har IKKE
+  // chrome.runtime.getManifest() — kaldet kaster "is not a function", saa dokumentet
+  // kunne aldrig oplyse sin version, `offscreenSvarer()` sammenlignede null mod vores
+  // og fik altid falsk, og broen blev revet ned tre gange hvert tiende minut for evigt.
+  // (Symptomet var "Offscreen document closed before fully loading" — nedrivningen
+  // ramte dokumentet mens det stadig startede op.)
+  // URL'en er baaret af dokumentet selv: et dokument oprettet af en aeldre udgave
+  // baerer den aeldre version, hvilket er praecis den skelnen tjekket skal bruge.
+  let minVersion = '';
+  try { minVersion = chrome.runtime.getManifest().version; } catch {}
+  await chrome.offscreen.createDocument({
+    url: 'offscreen.html' + (minVersion ? '?v=' + encodeURIComponent(minVersion) : ''),
+    reasons: ['WORKERS'],
+    justification: 'Maintain persistent WebSocket connection to local MCP server',
+  });
 }
 
 // ── Action Logging ─────────────────────────────────────────────────────────
@@ -842,12 +1248,19 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
   if (msg.type === 'mcp_command') {
     const port = msg.port;
     logAction(port, msg.method, msg.params);
-    // Restore sessions from storage (service worker may have restarted)
-    restoreSessions().then(() => {
-      dispatch(port, msg.method, msg.params)
-        .then(result => sendResponse(result))
-        .catch(err => sendResponse({ __error: err.message || String(err) }));
-    }).catch(err => sendResponse({ __error: err.message || String(err) })); // else a storage-restore reject hangs the caller
+    // Restore sessions from storage (service worker may have restarted), then take over any
+    // session orphaned by an unclean disconnect so navigate→click keeps hitting the same tab.
+    restoreSessions()
+      .then(() => adoptOrphanedSession(port, msg.pid).catch(() => null)) // adoption is best-effort, never fatal
+      .then(() => {
+        // Stempl pid'en ÉT sted, foer dispatch. De fem nedstroems getSession(port)-kald
+        // arver den derfra, saa ingen af dem behoever at kende til pid-begrebet.
+        getSession(port, msg.pid);
+        dispatch(port, msg.method, msg.params)
+          .then(result => sendResponse(result))
+          .catch(err => sendResponse({ __error: err.message || String(err) }));
+      })
+      .catch(err => sendResponse({ __error: err.message || String(err) })); // else a storage-restore reject hangs the caller
     return true; // async response
   }
 
@@ -857,10 +1270,28 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
   }
 
   if (msg.type === 'reconnect') {
-    chrome.offscreen.hasDocument().then(exists => {
-      if (exists) chrome.offscreen.closeDocument().then(() => ensureOffscreen());
-      else ensureOffscreen();
-    });
+    // FEJL RETTET 19/8: der var ingen fangst her. Lykkedes closeDocument()
+    // men fejlede ensureOffscreen() — fx fordi dokumentet stadig var ved at
+    // lukke — blev afvisningen slugt, og extensionen stod tilbage UDEN
+    // offscreen-dokument. Ingen WebSocket, ingen genopretning, og kun en
+    // manuel genindlaesning kunne redde den.
+    (async () => {
+      try {
+        if (await chrome.offscreen.hasDocument()) {
+          await chrome.offscreen.closeDocument();
+        }
+      } catch (e) {
+        console.warn('[BG] kunne ikke lukke offscreen:', e?.message || e);
+      }
+      // Proev at genskabe. Fejler det, tager hjerteslags-alarmen den
+      // inden for et minut — men kun fordi vi IKKE lader fejlen forsvinde.
+      try {
+        await ensureOffscreen();
+      } catch (e) {
+        console.error('[BG] kunne ikke genskabe offscreen:', e?.message || e);
+        setTimeout(() => ensureOffscreen().catch(console.error), 2000);
+      }
+    })();
     return;
   }
 
@@ -1351,26 +1782,73 @@ async function dismissOverlays(tabId, scope = 'non_critical', maxPasses = 3) {
       ];
       // "Ambiguous" texts MAY revert partial form data ("Cancel" usually reverts state)
       // — only used when overlay has no editable form fields, or in aggressive scope
+      // ── VETO-LISTE (MAALT 23/8 — det dyreste fund i hele auditten) ────────────
+      //
+      // Koert med den ORDRETTE kode mod knapper i en rigtig browser trykkede
+      // dismiss_overlays paa "Close account", "Close and delete everything",
+      // "Cancel subscription" og "Afvis betalingen permanent" — og paa enhver knap
+      // med aria-label="Close account" eller "Luk kontoen". Det skete i DEFAULT-scope,
+      // ikke kun aggressive.
+      //
+      // Aarsagen: "close" og "luk" er lovlige luk-ord, og matchningen havde ingen
+      // ord-graense. "Close account" indeholder "close". Og instruktionerne beder
+      // agenten kalde dismiss_overlays FOER hvert stoerre skridt, saa det ville ske
+      // paa hver eneste side hvor saadan en knap findes.
+      //
+      // Et luk-ord er derfor ikke laengere nok: findes ET af disse ord i teksten eller
+      // aria-labelen, klikkes der ALDRIG — uanset hvor godt resten matcher. Det er en
+      // veto, ikke en vaegtning. Et overlay der ikke bliver lukket koster et ekstra
+      // skridt; en lukket konto koster brugeren penge eller adgang.
+      const VETO = [
+        'account', 'konto', 'subscription', 'abonnement', 'membership', 'medlemskab',
+        'payment', 'betaling', 'kort', 'card', 'billing', 'faktura', 'invoice',
+        'delete', 'slet', 'remove', 'fjern', 'erase', 'wipe', 'destroy',
+        'permanent', 'permanently', 'forever', 'for evigt', 'irreversibl',
+        'unsubscribe', 'opsig', 'afmeld', 'terminate', 'opheav',
+        'deactivate', 'deaktiver', 'disable', 'deaktivér',
+        'sign out', 'log out', 'log ud', 'logout', 'sign-out',
+        'order', 'ordre', 'purchase', 'koeb', 'køb', 'refund', 'refunder',
+      ];
+      const erFarlig = (tekst) => {
+        const t = (tekst || '').toLowerCase();
+        return VETO.some((v) => t.includes(v));
+      };
+
       const ambiguousTexts = [
         "skip", "cancel", "afvis", "spring over",
       ];
       const xChars = ['×', '✕', '✖', '⨯'];
 
+      // MAALT 21/8: her stod `if (!el || !el.offsetParent && el.tagName !== 'BODY') return false`.
+      // offsetParent er ALTID null for et position:fixed-element — det er ikke en fejl i
+      // browseren, det er definitionen. Saa hele overlay-fjerneren var blind for praecis
+      // den slags elementer som cookie-bannere, samtykke-bjaelker og modaler ER. Et
+      // synligt fixed-banner med <button aria-label="Close"> blev hverken fundet som
+      // overlay eller som luk-knap: dismissed:[], skipped:[], count:0 — tavst intet.
+      //
+      // Rigtig synlighed laeses af layout og stil, ikke af offsetParent.
       const isVisible = (el) => {
-        if (!el || !el.offsetParent && el.tagName !== 'BODY') return false;
+        if (!el) return false;
         const rect = el.getBoundingClientRect();
-        return rect.width > 0 && rect.height > 0;
+        if (rect.width <= 0 || rect.height <= 0) return false;
+        const st = getComputedStyle(el);
+        if (st.display === 'none' || st.visibility === 'hidden' || st.visibility === 'collapse') return false;
+        if (parseFloat(st.opacity) === 0) return false;
+        return true;
       };
 
       const findCloseAffordance = (overlay, allowAmbiguous) => {
         const all = [...overlay.querySelectorAll('button, [role="button"], a[href="#"], [aria-label]')];
         const allTexts = allowAmbiguous ? [...safeTexts, ...ambiguousTexts] : safeTexts;
 
-        // Priority 1: aria-label match (close/dismiss/luk/afvis are always safe)
+        // Priority 1: aria-label match. MAALT 23/8: "always safe" var FORKERT — aria-label
+          // "Close account" indeholder "close", saa knappen blev trykket. Vetoet nedenfor
+          // er derfor det foerste der koeres, foer nogen match overhovedet forsoeges.
         for (const c of all) {
           if (!isVisible(c)) continue;
           const label = (c.getAttribute('aria-label') || '').toLowerCase();
           if (!label) continue;
+            if (erFarlig(label) || erFarlig(c.textContent)) continue;   // veto — se listen ovenfor
           if (label.includes('close') || label.includes('dismiss') || label.includes('luk')) {
             return { el: c, method: 'aria-label', label };
           }
@@ -1384,6 +1862,7 @@ async function dismissOverlays(tabId, scope = 'non_critical', maxPasses = 3) {
           if (!isVisible(c)) continue;
           const text = (c.textContent || '').trim().toLowerCase();
           if (!text || text.length > 30) continue;
+          if (erFarlig(text) || erFarlig(c.getAttribute('aria-label'))) continue;   // veto
           if (allTexts.some(t => text === t || text === t + '!' || text === t + '.')) {
             return { el: c, method: 'text-exact', label: text };
           }
@@ -1393,7 +1872,11 @@ async function dismissOverlays(tabId, scope = 'non_critical', maxPasses = 3) {
           if (!isVisible(c)) continue;
           const text = (c.textContent || '').trim().toLowerCase();
           if (!text || text.length > 40) continue;
-          if (allTexts.some(t => text.includes(t))) {
+          // MAALT 22/8: contains-passet gjorde "ok" til en delstreng-traeffer, saa
+          // "Book a demo", "Unlock account" og "Cookie settings" blev klikbare — i
+          // DEFAULT-scope. Korte ord maa kun matche eksakt (prioritet 2 ovenfor).
+          if (erFarlig(text) || erFarlig(c.getAttribute('aria-label'))) continue;   // veto
+          if (allTexts.filter(t => t.length >= 5).some(t => text.includes(t))) {
             return { el: c, method: 'text-contains', label: text };
           }
         }
@@ -1402,6 +1885,7 @@ async function dismissOverlays(tabId, scope = 'non_critical', maxPasses = 3) {
         for (const c of all) {
           if (!isVisible(c)) continue;
           const text = (c.textContent || '').trim();
+          if (erFarlig(c.getAttribute('aria-label'))) continue;   // et × med farlig aria-label
           if (xChars.includes(text)) {
             return { el: c, method: 'x-char', label: text };
           }
@@ -1423,6 +1907,21 @@ async function dismissOverlays(tabId, scope = 'non_critical', maxPasses = 3) {
         '[class*="banner" i]:not([class*="-hidden"]):not(input):not(button)',
         '[data-testid*="dialog" i]',
         '[data-testid*="modal" i]',
+        // MAALT 22/8 af flowtesten: listen matchede kun paa class, aldrig paa id. Et
+        // helt almindeligt <div id="banner"> blev derfor ALDRIG set som et overlay —
+        // og cookie-bannere skrives lige saa ofte med id som med class. Hullet var
+        // skjult indtil i dag, fordi det strukturelle fixed/sticky-spor fangede dem
+        // alligevel; det spor blev skaaret efter sikkerhedsreview, og saa stod hullet
+        // bart. De samme fem ord, samme regler — bare paa id.
+        //
+        // Det her er IKKE det skaarne spor i ny form: her har sideforfatteren selv
+        // kaldt elementet en dialog/modal/banner. Det er en eksplicit erklaering, ikke
+        // et gaet ud fra placering, saa faren ved delstrengs-matchning gaelder ikke.
+        '[id*="modal" i]:not(input):not(button)',
+        '[id*="overlay" i]:not(input):not(button)',
+        '[id*="popover" i]:not(input):not(button)',
+        '[id*="banner" i]:not(input):not(button)',
+        '[id*="dialog" i]:not(input):not(button)',
       ];
       for (const sel of selectors) {
         try {
@@ -1434,6 +1933,15 @@ async function dismissOverlays(tabId, scope = 'non_critical', maxPasses = 3) {
         } catch {}
       }
 
+      // Et strukturelt spor (alt fixed/sticky over 40x20px som overlay-kandidat) blev
+      // proevet 21/8 og SKAARET 22/8 efter sikkerhedsreview: findCloseAffordance matcher
+      // paa delstrenge, saa "Cancel subscription", "Close account" og "Book now" (via "ok")
+      // alle blev klikkbare — paa hver eneste side, og instruktionerne beder agenten kalde
+      // dismiss_overlays foer hvert stoerre skridt. Den maalte fejl var offsetParent-
+      // blindheden i isVisible ovenfor; den er rettet. Sporet var ny adfaerd uden bevist
+      // behov. Genindfoeres kun med eksakt tekstmatch og et krav om luk-affordance som
+      // direkte barn.
+
       for (const overlay of overlays) {
         const role = overlay.getAttribute('role') || (overlay.className || '').split(' ')[0] || 'unknown';
 
@@ -1690,13 +2198,86 @@ async function dropFileOnTarget(tabId, selector, files) {
     }
   }
 
+  // Strategy 2 (v1.27): intercept the NATIVE OS file chooser.
+  //
+  // Sites like Google Ads never put an <input type="file"> in the DOM — clicking
+  // their "choose a file" control opens the OS dialog directly, which no browser
+  // automation can reach. Page.setInterceptFileChooserDialog makes Chrome fire
+  // Page.fileChooserOpened instead of showing that dialog, and the event carries
+  // the backendNodeId of the element that requested it. DOM.setFileInputFiles
+  // accepts a backendNodeId, so we can satisfy the request programmatically.
+  //
+  // Order matters: interception must be armed BEFORE the click that opens the
+  // chooser, otherwise the OS dialog is already up and the event never fires.
+  const chooserResult = await interceptFileChooser(tabId, selector, fileList);
+  if (chooserResult) return chooserResult;
+
   return {
     ok: false,
     error: 'no-file-input-found',
-    hint: 'No <input type="file"> found in target subtree, parent, or page. Pure drag-drop zones (without backing input) require synthesizing File objects from disk content via mcp-server, which is not yet implemented. Try selecting a more specific selector, or fall back to manual upload via browser_ask_user.',
+    hint: 'No <input type="file"> found, and the native file-chooser interception did not fire. The trigger element may not open a file dialog at all — check the selector.',
   };
 }
 
+// Arms Page.fileChooserOpened, clicks the trigger, and fulfils the chooser with
+// the given files. Returns null if no chooser opened (so the caller can fall
+// through to its own error), or a result object on success/explicit failure.
+async function interceptFileChooser(tabId, selector, fileList) {
+  try {
+    await debuggerAttach(tabId);
+    await cdpSend(tabId, 'Page.enable', {});
+    await cdpSend(tabId, 'DOM.enable', {});
+    await cdpSend(tabId, 'Page.setInterceptFileChooserDialog', { enabled: true });
+  } catch (e) {
+    return null; // interception unavailable — let caller report the original error
+  }
+
+  try {
+    return await new Promise((resolve) => {
+      let settled = false;
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        chrome.debugger.onEvent.removeListener(listener);
+        clearTimeout(timer);
+        resolve(value);
+      };
+
+      const listener = (source, method, eventParams) => {
+        if (source.tabId !== tabId || method !== 'Page.fileChooserOpened') return;
+        const backendNodeId = eventParams?.backendNodeId;
+        if (!backendNodeId) {
+          finish({ ok: false, error: 'file-chooser-without-node', detail: 'Chrome fired fileChooserOpened but supplied no backendNodeId.' });
+          return;
+        }
+        cdpSend(tabId, 'DOM.setFileInputFiles', { backendNodeId, files: fileList })
+          .then(() => finish({
+            ok: true,
+            method: 'native-chooser-intercepted',
+            files: fileList,
+            mode: eventParams.mode,
+          }))
+          .catch(e => finish({ ok: false, error: 'setFileInputFiles-failed', detail: e?.message || String(e) }));
+      };
+      chrome.debugger.onEvent.addListener(listener);
+
+      // 8s: the click is local, so the chooser opens within a frame or two.
+      // A longer wait would just stall the caller when the element opens no dialog.
+      const timer = setTimeout(() => finish(null), 8000);
+
+      // Click the trigger so the page asks for the chooser. Real mouse events —
+      // a synthetic .click() does not always reach the file-picker code path.
+      (async () => {
+        const el = await resolveElement(tabId, selector);
+        if (!el) { finish({ ok: false, error: 'trigger-not-found', detail: selector }); return; }
+        await debuggerClick(tabId, el.x, el.y);
+      })().catch(e => finish({ ok: false, error: 'trigger-click-failed', detail: e?.message || String(e) }));
+    });
+  } finally {
+    try { await cdpSend(tabId, 'Page.setInterceptFileChooserDialog', { enabled: false }); } catch {}
+  }
+}
+
 // ── Command Dispatcher ──────────────────────────────────────────────────────
 
 async function dispatch(port, method, params) {
@@ -1754,11 +2335,84 @@ async function dispatch(port, method, params) {
       return { content, url: tab.url, title: tab.title, method: 'debugger' };
     }
 
+    // Read EVERY row of a virtualised list by scrolling its container until the set stops
+    // growing. Outlook, Gmail and most mail/table UIs keep only ~7 rows in the DOM, so a
+    // single get_page_content sees a sliver — this walks the whole list instead.
+    case 'extract_list': {
+      const tab = await getSessionTab(port);
+      if (tab.url.startsWith('chrome://')) throw new Error('Cannot access chrome:// pages');
+      const rowSel = params.selector;
+      if (!rowSel) throw new Error('extract_list requires `selector` (the repeating row element)');
+      const containerSel = params.container || null;
+      const maxRows = Math.min(params.max_rows || 500, 5000);
+      const stableNeeded = params.stable_rounds || 3;
+      const waitMs = params.wait_ms || 350;
+
+      const seen = new Set();
+      let stable = 0, rounds = 0, atEnd = false;
+      const MAX_ROUNDS = 300; // backstop: a list that never stabilises must not spin forever
+
+      while (seen.size < maxRows && stable < stableNeeded && rounds < MAX_ROUNDS) {
+        rounds++;
+        const r = await safeExecuteScript(tab.id, (rs, cs, keep) => {
+          const rows = Array.from(document.querySelectorAll(rs));
+          const texts = rows
+            .map(el => (el.innerText || el.textContent || '').replace(/\s+/g, ' ').trim())
+            .filter(t => t.length > 0);
+
+          // Scroll the row's own scrollable ancestor — scrolling window does nothing when the
+          // list lives in an inner overflow container (the normal case in webmail).
+          let c = cs ? document.querySelector(cs) : null;
+          if (!c && rows.length) {
+            let p = rows[0].parentElement;
+            while (p && p !== document.documentElement) {
+              const s = getComputedStyle(p);
+              if (/(auto|scroll)/.test(s.overflowY) && p.scrollHeight > p.clientHeight + 20) { c = p; break; }
+              p = p.parentElement;
+            }
+          }
+          const step = keep || (c ? c.clientHeight : window.innerHeight) * 0.85;
+          const before = c ? c.scrollTop : window.scrollY;
+          if (c) c.scrollTop = before + step; else window.scrollBy(0, step);
+          const after = c ? c.scrollTop : window.scrollY;
+          const done = c
+            ? c.scrollTop + c.clientHeight >= c.scrollHeight - 4
+            : window.scrollY + window.innerHeight >= document.documentElement.scrollHeight - 4;
+          return { texts, moved: after - before, done, container: !!c };
+        }, [rowSel, containerSel, params.scroll_step || 0]);
+
+        if (r.cspBlocked) throw new Error('extract_list: this page blocks script injection — use screenshots instead');
+        const data = r.result || { texts: [] };
+        const before = seen.size;
+        for (const t of data.texts) seen.add(t);
+        // Two independent stop signals: nothing new appeared, or the container hit its end.
+        if (seen.size === before) stable++; else stable = 0;
+        if (data.done) { atEnd = true; stable++; }
+        if (!data.texts.length && rounds > 2) break; // selector matches nothing — fail fast
+        await new Promise(res => setTimeout(res, waitMs));
+      }
+
+      return {
+        rows: [...seen],
+        count: seen.size,
+        rounds,
+        reached_end: atEnd,
+        truncated: seen.size >= maxRows,
+      };
+    }
+
     case 'screenshot': {
-      // getSessionTab(…, true) is focus-NEUTRAL now: it un-minimizes + activates the tab
-      // but does NOT steal window focus (FIX-1). Screenshots run constantly, so the common
-      // path must never yank Chrome to the foreground.
-      const tab = await getSessionTab(port, true);
+      // EKSPERIMENT 21/8: fanen aktiveres IKKE laengere.
+      //
+      // getSessionTab(…, true) stjal ikke VINDUES-fokus (FIX-1), men den kaldte stadig
+      // chrome.tabs.update({active:true}) — altsaa et fane-skift INDE i vinduet. Sidder
+      // brugeren i det samme Chrome-vindue paa sin egen fane, bliver den revet vaek hver
+      // eneste gang agenten tager et billede. Og billeder tages konstant.
+      //
+      // Aktiveringen er formentlig unoedvendig: CDP Page.captureScreenshot nedenfor
+      // fotograferer en fane der ikke er forrest. Den okkluderede sidste-udvej loefter
+      // stadig vinduet hvis CDP virkelig ikke kan producere en frame.
+      const tab = await getSessionTab(port, false);
       if (tab.url.startsWith('chrome://') || tab.url.startsWith('about:')) {
         throw new Error(`Cannot screenshot ${tab.url.split(':')[0]}: pages — navigate to a real page first`);
       }
@@ -1816,6 +2470,12 @@ async function dispatch(port, method, params) {
 
     case 'execute_script': {
       // v1.22.2 (DIAGNOSTIC): Try scripting paths but log all errors so we can see WHY they fail
+      // v1.26: accept `script` as alias for `code` — the historic param-name mismatch caused
+      // silent "unserializable"/undefined failures that read as "execute_script is broken".
+      if (params.code == null && typeof params.script === 'string') params.code = params.script;
+      if (typeof params.code !== 'string' || !params.code.trim()) {
+        return { ok: false, error: 'Missing code. Pass a JavaScript EXPRESSION in `code` (e.g. an IIFE: (() => {...; return x;})()). `return ...` at top level is invalid — the handler wraps code in parentheses.' };
+      }
       const tab = await getSessionTab(port);
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot execute scripts on chrome:// pages');
 
@@ -1932,14 +2592,48 @@ async function dispatch(port, method, params) {
       try {
         const el = await resolveElement(tab.id, params.selector);
         if (!el) return { ok: false, error: 'Element not found: ' + params.selector };
+        // Elementet findes, men har ingen udstraekning — at klikke ville ramme (0,0),
+        // altsaa et HELT andet element end det der blev bedt om. Sig det i stedet.
+        if (el.hidden) {
+          return {
+            ok: false,
+            error: 'Element fundet men ikke synligt (0x0) — klik ville ramme sidens hjoerne: ' + params.selector,
+            hidden: true,
+            tag: el.tag,
+          };
+        }
 
         // Primary path: debugger mouse events (isTrusted=true, works on React/Angular SPAs)
-        await debuggerClick(tab.id, el.x, el.y);
-        return { ok: true, method: el.method || 'debugger', tag: el.tag, text: el.text };
+        const clickResult = await debuggerClick(tab.id, el.x, el.y);
+        return {
+          ok: true,
+          method: el.method || 'debugger',
+          tag: el.tag,
+          text: el.text,
+          // MAALT 21/8: `landed` blev allerede beregnet inde i debuggerClick og smidt vaek,
+          // saa `click` svarede ok:true selv naar siden slet ikke reagerede. Nu foelger den med:
+          // landed=false betyder "eventet blev sendt, men intet handler tog imod det".
+          ...(clickResult || {}),
+        };
       } catch (e) {
         // Fallback: synthetic click via chrome.scripting for anti-automation sites
         // (Apple ASC etc.) OR user-blocked-debugger scenarios.
-        if (/Debugger detached/.test(e?.message || '')) {
+        //
+        // MÅLT 29/7: betingelsen var kun /Debugger detached/, men den HYPPIGSTE fejl hedder
+        // "Debugger attach failed after 3 attempts" (kastes l.298) — altså når Chrome nægter
+        // at koble debuggeren på overhovedet. De to strenge ligner hinanden og betyder næsten
+        // det samme, men regexet ramte kun den ene, så fallbacken fyrede aldrig i det tilfælde
+        // den var skrevet til: "user-blocked-debugger scenarios" står ordret i kommentaren
+        // ovenfor, og det var netop dét den ikke dækkede.
+        //
+        // Konsekvens i praksis: klikker brugeren Cancel på Chromes debugger-banner ÉN gang,
+        // husker Chrome det på tværs af extension-reloads, og hvert eneste klik fejler
+        // permanent — selvom scriptingClick ville have virket hele tiden. Den bruger `func:`
+        // og ikke en kode-streng, så den rammes ikke af sidens CSP.
+        //
+        // Prisen ved fallbacken er at klikket mister isTrusted=true. Det tjekker de færreste
+        // sider, og et klik der virker på 95% af nettet slår et klik der aldrig virker.
+        if (/Debugger detached|Debugger attach failed|not attached/i.test(e?.message || '')) {
           const r = await scriptingClick(tab.id, params.selector);
           if (r.ok) return { ok: true, method: 'scripting-fallback', tag: r.tag };
         }
@@ -2077,6 +2771,11 @@ async function dispatch(port, method, params) {
       const r = await setCombobox(tab.id, params.selector, values, {
         multi: !!params.multi,
         query_chars: params.query_chars,
+        // MAALT 22/8: wait_ms blev tavst kasseret her. Skemaet lover parameteren, og
+        // setCombobox laeser opts.wait_ms — men handleren videregav den ikke, saa
+        // ventetiden stod altid paa standarden 3000 ms. En agent der bad om laengere
+        // tid til en langsom liste fik den ikke, og fik ingen besked om det.
+        wait_ms: params.wait_ms,
       });
       const visibleErrors = r.ok ? [] : await collectVisibleErrors(tab.id, params.selector);
       return r.ok ? r : { ...r, visible_errors: visibleErrors };
@@ -2085,7 +2784,8 @@ async function dispatch(port, method, params) {
     case 'drop_file': {
       const tab = await getSessionTab(port);
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
-      const files = Array.isArray(params.files) ? params.files : [params.files || params.file];
+      const files = Array.isArray(params.files) ? params.files
+                  : [params.files || params.file || params.file_path].filter(Boolean);
       if (!files[0]) return { ok: false, error: 'files or file required' };
       return await dropFileOnTarget(tab.id, params.selector || 'body', files);
     }
@@ -2116,8 +2816,9 @@ async function dispatch(port, method, params) {
     }
 
     case 'press_key': {
-      // v1.22: activate tab so key-event lands in foreground (otherwise Chrome routes to active tab)
-      const tab = await getSessionTab(port, true);
+      // EKSPERIMENT 21/8: aktiverer IKKE fanen. Kommentaren her sagde at Chrome ellers
+      // sender tastetrykket til den aktive fane — det maales nu i stedet for at antages.
+      const tab = await getSessionTab(port, false);
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
       const key = params.key; // e.g. "Enter", "Tab", "Escape", "ArrowDown"
       const modifiers = (params.ctrl ? 2 : 0) | (params.alt ? 1 : 0) | (params.shift ? 8 : 0) | (params.meta ? 4 : 0);
@@ -2196,6 +2897,65 @@ async function dispatch(port, method, params) {
       return { ok: true, scrolled: { x: dx, y: dy }, method: 'mouseWheel-stepped' };
     }
 
+    // ── v1.26 "superior" tools ──────────────────────────────────────────────
+    // to the MCP server — only lengths and shape booleans. Born from the 2026-07-27
+    // Azure-secret night: the agent must be able to move a credential from page to
+    // field without the value ever entering the LLM context or transcript.
+
+    case 'double_click': {
+      const tab = await getSessionTab(port);
+      if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
+      const el = await resolveElement(tab.id, params.selector);
+      if (!el) return { ok: false, error: 'Element not found: ' + params.selector };
+      await debuggerAttach(tab.id);
+      const { x, y } = el;
+      await cdpSend(tab.id, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+      await new Promise(r => setTimeout(r, 30));
+      // Proper dblclick: two press/release pairs with escalating clickCount.
+      await dispatchTaalmodigt(tab.id, { type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 1 });
+      await dispatchTaalmodigt(tab.id, { type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 1 });
+      await new Promise(r => setTimeout(r, 40));
+      await dispatchTaalmodigt(tab.id, { type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 2 });
+      await dispatchTaalmodigt(tab.id, { type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 2 });
+      return { ok: true, double_clicked: true, tag: el.tag, text: el.text };
+    }
+
+    case 'right_click': {
+      const tab = await getSessionTab(port);
+      if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
+      const el = await resolveElement(tab.id, params.selector);
+      if (!el) return { ok: false, error: 'Element not found: ' + params.selector };
+      await debuggerAttach(tab.id);
+      const { x, y } = el;
+      await cdpSend(tab.id, 'Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+      await new Promise(r => setTimeout(r, 30));
+      await dispatchTaalmodigt(tab.id, { type: 'mousePressed', x, y, button: 'right', buttons: 2, clickCount: 1 });
+      await dispatchTaalmodigt(tab.id, { type: 'mouseReleased', x, y, button: 'right', buttons: 0, clickCount: 1 });
+      return { ok: true, right_clicked: true, tag: el.tag, text: el.text, note: 'contextmenu event fired; native Chrome menu does not open via CDP — page-level menus (OWA, web apps) do' };
+    }
+
+    case 'click_xy': {
+      // Raw coordinate click — the escape hatch for custom widgets whose buttons
+      // resist every selector strategy (Azure portal dialogs, KO-bound divs).
+      // Coordinates come from the caller's own screenshot analysis.
+      const tab = await getSessionTab(port);
+      if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
+      if (typeof params.x !== 'number' || typeof params.y !== 'number') {
+        return { ok: false, error: 'x and y (numbers, CSS pixels in viewport) are required' };
+      }
+      await debuggerClick(tab.id, params.x, params.y);
+      return { ok: true, clicked_at: { x: params.x, y: params.y } };
+    }
+
+    case 'reattach_debugger': {
+      // Ghost-attach recovery without full extension reload: force detach + fresh attach.
+      const tab = await getSessionTab(port);
+      try { await chrome.debugger.detach({ tabId: tab.id }); } catch {}
+      await new Promise(r => setTimeout(r, 150));
+      await debuggerAttach(tab.id);
+      return { ok: true, reattached: true, tab_id: tab.id };
+    }
+
     case 'hover': {
       const tab = await getSessionTab(port);
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
@@ -2226,21 +2986,45 @@ async function dispatch(port, method, params) {
         })()
       `);
 
+      // `value` og `label` accepteres som alias for `option`. Uden dem gav et forkert
+      // navn "undefined" som soegetekst — og vaerktoejet svarede alligevel ok:true.
+      const oensket = params.option ?? params.value ?? params.label;
+      if (typeof oensket !== 'string' || !oensket) {
+        return { ok: false, error: 'Manglende `option` (teksten eller vaerdien paa den mulighed der skal vaelges).' };
+      }
+
       if (isNativeSelect) {
-        // Native <select> — set value directly
-        await debuggerEval(tab.id, `
+        // MAALT 21/8: her blev resultatet af evalueringen — `return !!opt` — kastet vaek,
+        // og handleren svarede ubetinget ok:true. Blev muligheden ikke fundet, skete der
+        // INTET, og svaret sagde stadig at det var lykkedes. Samme fejlklasse som klikket
+        // der svarede ok:true uden at siden reagerede. Nu laeses svaret, og der laeses
+        // TILBAGE fra feltet bagefter, saa "valgt" betyder at vaerdien faktisk staar der.
+        const valg = await debuggerEval(tab.id, `
           (function() {
             const sel = document.querySelector(${JSON.stringify(params.selector)});
-            const opt = Array.from(sel.options).find(o => o.text.includes(${JSON.stringify(params.option)}) || o.value === ${JSON.stringify(params.option)});
-            if (opt) {
-              sel.value = opt.value;
-              sel.dispatchEvent(new Event('change', { bubbles: true }));
-              sel.dispatchEvent(new Event('input', { bubbles: true }));
+            if (!sel) return JSON.stringify({ found: false, error: 'select ikke fundet' });
+            const oensket = ${JSON.stringify(oensket)};
+            const opt = Array.from(sel.options).find(o => o.value === oensket)
+                     || Array.from(sel.options).find(o => o.text.trim() === oensket)
+                     || Array.from(sel.options).find(o => o.text.includes(oensket));
+            if (!opt) {
+              return JSON.stringify({ found: false, error: 'Ingen mulighed matchede: ' + oensket,
+                available: Array.from(sel.options).map(o => o.text.trim()).slice(0, 25) });
             }
-            return !!opt;
+            sel.value = opt.value;
+            sel.dispatchEvent(new Event('input', { bubbles: true }));
+            sel.dispatchEvent(new Event('change', { bubbles: true }));
+            return JSON.stringify({ found: true, wanted: opt.value, actual: sel.value, text: opt.text.trim() });
           })()
         `);
-        return { ok: true, type: 'native_select' };
+        let r; try { r = JSON.parse(valg); } catch { r = null; }
+        if (!r) return { ok: false, type: 'native_select', error: 'Kunne ikke laese resultatet af valget' };
+        if (!r.found) return { ok: false, type: 'native_select', error: r.error, available: r.available };
+        if (r.actual !== r.wanted) {
+          // Reagerede siden ved at rulle valget tilbage (React-styret select), skal det siges.
+          return { ok: false, type: 'native_select', error: `Valget blev rullet tilbage: satte "${r.wanted}", feltet staar paa "${r.actual}"` };
+        }
+        return { ok: true, type: 'native_select', selected: r.text, value: r.actual };
       }
 
       // Custom dropdown (Angular Material, React Select, etc.)
@@ -2253,57 +3037,75 @@ async function dispatch(port, method, params) {
       await new Promise(r => setTimeout(r, params.wait || 300));
 
       // Step 3: Find and click the option by text
-      const option = await resolveElement(tab.id, `text=${params.option}`);
-      if (!option) return { ok: false, error: 'Option not found: ' + params.option };
-      await debuggerClick(tab.id, option.x, option.y);
-
-      return { ok: true, type: 'custom_dropdown', selected: params.option };
+      const option = await resolveElement(tab.id, `text=${oensket}`);
+      if (!option) return { ok: false, error: 'Option not found: ' + oensket };
+      const valgKlik = await debuggerClick(tab.id, option.x, option.y);
+
+      // MAALT 22/8 ved review: aerlighedsfixet blev kun anvendt paa native-grenen
+      // ovenfor. Her stod stadig `return { ok: true }` ubetinget, selv om resultatet
+      // af klikket var beregnet og smidt vaek — praecis den fejl der blev lukket to
+      // gange andre steder samme dag. En brugerdefineret dropdown hvor klikket ikke
+      // blev taget imod, meldte altsaa stadig succes.
+      // MAALT 22/8 (tredje gang samme fejlklasse): `ok: true` stod hardkodet, og `landed`
+      // blev blot spredt ind ved siden af. En dropdown hvor klikket ikke blev taget imod
+      // svarede altsaa {ok:true, landed:false} — og agenten laeser ok. Beskrivelsen lover
+      // ordret "it never reports success without the field actually changing".
+      return {
+        ...(valgKlik || {}),
+        ok: valgKlik?.landed !== false,
+        type: 'custom_dropdown',
+        selected: oensket,
+        ...(valgKlik?.landed === false
+          ? { error: 'Klikket paa muligheden blev ikke taget imod af siden: ' + oensket }
+          : {}),
+      };
     }
 
     case 'handle_dialog': {
-      // Auto-handle JS alert/confirm/prompt dialogs
-      // Must be set up BEFORE the dialog appears
       const tab = await getSessionTab(port);
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
-      const action = params.action || 'accept'; // accept, dismiss
+      const action = params.action === 'dismiss' ? 'dismiss' : 'accept';
       const promptText = params.text || '';
+      const vent = params.wait === true;              // gammel, blokerende adfaerd
+      const levetid = params.timeout || 60000;
 
       await debuggerAttach(tab.id);
-      try {
-        // Enable page events to catch dialogs
-        await cdpSend(tab.id, 'Page.enable', {});
+      await cdpSend(tab.id, 'Page.enable', {});
+      afvaebnDialog(tab.id, 'en ny armering overtog denne fane');   // kun én ad gangen
+
+      let opfyld;
+      const svar = new Promise((resolve) => { opfyld = resolve; });
+
+      const listener = (source, method, eventParams) => {
+        if (source.tabId !== tab.id || method !== 'Page.javascriptDialogOpening') return;
+        afvaebnDialog(tab.id);   // uden grund: vi svarer selv lige nedenfor
+        cdpSend(tab.id, 'Page.handleJavaScriptDialog', {
+          accept: action === 'accept',
+          promptText,
+        })
+          .then(() => opfyld({ ok: true, dialog_type: eventParams.type, message: eventParams.message, action }))
+          .catch((e) => opfyld({ ok: false, error: e.message }));
+      };
 
-        // Wait for dialog to appear (or handle existing one)
-        const result = await new Promise((resolve) => {
-          const timeout = setTimeout(() => {
-            chrome.debugger.onEvent.removeListener(listener);
-            resolve({ ok: false, error: 'No dialog appeared within timeout' });
-          }, params.timeout || 10000);
+      const timer = setTimeout(() => {
+        afvaebnDialog(tab.id);
+        opfyld({ ok: false, error: `Ingen dialog dukkede op inden for ${levetid} ms` });
+      }, levetid);
 
-          const listener = (source, method, eventParams) => {
-            if (source.tabId !== tab.id || method !== 'Page.javascriptDialogOpening') return;
-            chrome.debugger.onEvent.removeListener(listener);
-            clearTimeout(timeout);
-
-            cdpSend(tab.id, 'Page.handleJavaScriptDialog', {
-              accept: action === 'accept',
-              promptText: promptText,
-            }).then(() => {
-              resolve({
-                ok: true,
-                dialog_type: eventParams.type,
-                message: eventParams.message,
-                action,
-              });
-            }).catch(e => resolve({ ok: false, error: e.message }));
-          };
-          chrome.debugger.onEvent.addListener(listener);
-        });
+      armeredeDialoger.set(tab.id, { listener, timer, action, opfyld });
+      dialogLoefter.set(tab.id, svar);
+      chrome.debugger.onEvent.addListener(listener);
 
-        return result;
-      } finally {
-        await debuggerDetach(tab.id);
-      }
+      if (vent) return await svar;
+
+      // Armeret. Debuggeren bliver siddende — frakobler vi her, doer lytteren med den.
+      return {
+        ok: true,
+        armed: true,
+        action,
+        expires_in_ms: levetid,
+        note: 'Naeste dialog paa denne fane haandteres automatisk. Klik nu paa det der aabner den.',
+      };
     }
 
     case 'wait_for_network': {
@@ -2629,7 +3431,24 @@ async function dispatch(port, method, params) {
             setTimeout(() => { if (document.getElementById('a360-overlay')) { overlay.remove(); resolve({ acknowledged: false, action: 'timeout', values: {} }); } }, timeout);
           });
         },
-        args: [params.message, params.title, fields, hasFields, timeout, session.label],
+        // MAALT 21/8: her stod `params.title` raat. Skemaet siger at title er VALGFRI
+        // med standarden "Agent360 — Action Required", men udelades den, er vaerdien
+        // undefined — og chrome.scripting.executeScript afviser hele kaldet med
+        // "Error at property 'args': Error at index 1: Value is unserializable".
+        // Altsaa styrtede human-in-the-loop-vaerktoejet hver gang en agent fulgte sit
+        // eget skema. Det blev aldrig fanget, fordi ask_user stod som "springes over"
+        // i flowtesten — den eneste der kunne have set det.
+        //
+        // Alle argumenter tvinges nu til serialiserbare vaerdier, og standarden
+        // anvendes der hvor den er lovet.
+        args: [
+          String(params.message ?? ''),
+          String(params.title ?? 'Agent360 — Action Required'),
+          Array.isArray(fields) ? fields : [],
+          Boolean(hasFields),
+          Number(timeout) || 120000,
+          String(session.label ?? 'Claude'),
+        ],
         world: 'MAIN',
       });
 
@@ -2650,13 +3469,35 @@ async function dispatch(port, method, params) {
         return { error: `Frame ${frameIndex} not found. Available: ${frames?.length || 0} frames`, frames: frames?.map((f, i) => ({ index: i, url: f.url })) };
       }
       const frameId = frames[frameIndex].frameId;
+      // MAALT 21/8: her stod `func: new Function('return (' + code + ')')`. Den byggede
+      // funktionen i SERVICE-WORKEREN, hvor udvidelsens egen CSP forbyder eval — saa
+      // vaerktoejet fejlede paa hver eneste side, ogsaa med koden '1+1':
+      //   "Evaluating a string as JavaScript violates ... 'unsafe-eval' is not allowed".
+      // execute_script loeser det samme problem korrekt: send koden med som ARGUMENT og
+      // byg funktionen INDE i den injicerede func, hvor sidens egen CSP gaelder. Samme
+      // vej her.
+      //
+      // Og som i execute_script (v1.26): accepter `script` som alias for `code`. Samme
+      // navne-uoverensstemmelse har foer faaet vaerktoejer til at se brudte ud i tavshed.
+      if (params.code == null && typeof params.script === 'string') params.code = params.script;
       const code = params.code || 'document.body.innerText.slice(0, 5000)';
       const [result] = await chrome.scripting.executeScript({
         target: { tabId: tab.id, frameIds: [frameId] },
-        func: new Function('return (' + code + ')'),
         world: 'MAIN',
+        args: [code],
+        func: (codeStr) => {
+          try {
+            return { __ok: true, value: new Function('return (' + codeStr + ')')() };
+          } catch (e) {
+            return { __scriptingError: true, message: String(e?.message || e) };
+          }
+        },
       });
-      return { result: result.result, frame_url: frames[frameIndex].url };
+      const r = result?.result;
+      if (r && r.__scriptingError) {
+        return { ok: false, error: r.message, frame_url: frames[frameIndex].url };
+      }
+      return { result: r?.value, frame_url: frames[frameIndex].url };
     }
 
     case 'list_frames': {
@@ -2694,6 +3535,9 @@ async function dispatch(port, method, params) {
       if (!session.tabIds.has(tabId)) {
         throw new Error(`Tab ${tabId} does not belong to this session (${session.label})`);
       }
+      // Maerk lukningen som agentens egen. Ellers laeser onRemoved den tomme session som
+      // "brugeren er faerdig" og lukker serveren ned midt i samtalen (MAALT 22/8).
+      agentLukkedeFaner.add(tabId);
       await chrome.tabs.remove(tabId);
       session.tabIds.delete(tabId);
       if (session.activeTabId === tabId) session.activeTabId = null;
@@ -2757,8 +3601,19 @@ async function dispatch(port, method, params) {
           return info;
         }
 
-        // Get the DOM node ID for the file input
-        const { result: docResult } = await cdpSend(tab.id, 'DOM.getDocument', {});
+        // Get the DOM node ID for the file input.
+        //
+        // MAALT 21/8: her stod `const { result: docResult } = await cdpSend(...)`.
+        // Runtime.evaluate ovenfor svarer {result:{...}}, men DOM.getDocument svarer
+        // {root:{...}} — moenstret var kopieret fra det ene kald til det andet. Saa
+        // docResult var undefined, og vaerktoejet doede paa
+        // "Cannot read properties of undefined (reading 'root')" ved HVERT eneste kald.
+        // browser_upload_file kunne ikke uploade en fil paa nogen side overhovedet.
+        const docResult = await cdpSend(tab.id, 'DOM.getDocument', {});
+        if (!docResult?.root?.nodeId) {
+          await debuggerDetach(tab.id);
+          return { ok: false, error: 'DOM.getDocument gav intet rod-element' };
+        }
         const { nodeId } = await cdpSend(tab.id, 'DOM.querySelector', {
           nodeId: docResult.root.nodeId,
           selector: selector,
@@ -2769,8 +3624,16 @@ async function dispatch(port, method, params) {
           return { found: false, error: 'Could not get DOM node for file input' };
         }
 
-        // Set files on the input using CDP
-        const files = Array.isArray(params.files) ? params.files : [params.files || params.file];
+        // Set files on the input using CDP.
+        // `file_path` accepteres som alias for `file`/`files` — praecis samme navne-faelde
+        // som execute_script fik lukket i v1.26. Et forkert navn gav [undefined] og en
+        // upload der saa ud til at lykkes.
+        const files = Array.isArray(params.files) ? params.files
+                    : [params.files || params.file || params.file_path].filter(Boolean);
+        if (!files.length) {
+          await debuggerDetach(tab.id);
+          return { ok: false, error: 'Ingen fil angivet. Brug `files` (array) eller `file` (enkelt sti).' };
+        }
         await cdpSend(tab.id, 'DOM.setFileInputFiles', {
           nodeId: nodeId,
           files: files,
@@ -2904,10 +3767,10 @@ async function clickRecaptchaCheckbox(tabId) {
       type: 'mouseMoved', x: pos.x, y: pos.y,
     });
     await new Promise(r => setTimeout(r, 100 + Math.random() * 200));
-    await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+    await dispatchTaalmodigt(tabId, {
       type: 'mousePressed', x: pos.x, y: pos.y, button: 'left', clickCount: 1,
     });
-    await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+    await dispatchTaalmodigt(tabId, {
       type: 'mouseReleased', x: pos.x, y: pos.y, button: 'left', clickCount: 1,
     });
     await debuggerDetach(tabId);
@@ -2968,10 +3831,10 @@ async function clickCaptchaGridCells(tabId, cells) {
         type: 'mouseMoved', x: ox, y: oy,
       });
       await new Promise(r => setTimeout(r, 150 + Math.random() * 300));
-      await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+      await dispatchTaalmodigt(tabId, {
         type: 'mousePressed', x: ox, y: oy, button: 'left', clickCount: 1,
       });
-      await cdpSend(tabId, 'Input.dispatchMouseEvent', {
+      await dispatchTaalmodigt(tabId, {
         type: 'mouseReleased', x: ox, y: oy, button: 'left', clickCount: 1,
       });
       await new Promise(r => setTimeout(r, 200 + Math.random() * 400));
@@ -2995,9 +3858,42 @@ async function clickCaptchaGridCells(tabId, cells) {
 ensureOffscreen().catch(console.error);
 
 chrome.runtime.onStartup.addListener(() => ensureOffscreen().catch(console.error));
-chrome.runtime.onInstalled.addListener(() => ensureOffscreen().catch(console.error));
+// onInstalled fyrer ved installation, opdatering OG ved "Genindlaes" paa
+// chrome://extensions. I alle tre tilfaelde er koden aendret pr. definition, saa en
+// overlevende bro er per definition forældet — uanset hvor villigt den svarer paa ping.
+// MAALT 22/8: uden tvangen slog en genindlaesning aldrig igennem til broen, og
+// udvikling krævede en fuld genstart af Chrome hver gang.
+chrome.runtime.onInstalled.addListener(async () => {
+  try {
+    if (await chrome.offscreen.hasDocument()) await chrome.offscreen.closeDocument();
+  } catch (e) {
+    console.warn('[BG] kunne ikke lukke broen ved genindlaesning:', e?.message || e);
+  }
+  await chrome.storage.local.set({ offscreenGenskabt: 0, offscreenPauseTil: 0 });
+  ensureOffscreen().catch(console.error);
+});
+
+// Hjerteslag der genskaber offscreen-dokumentet hvis Chrome har ryddet det.
+//
+// FEJL RETTET 19/8: alarmen blev oprettet paa oeverste niveau ved HVER
+// service-worker-opstart. chrome.alarms.create() med et navn der allerede
+// findes NULSTILLER nedtaellingen — saa hvis workeren vaagnede oftere end
+// hvert minut (hvilket den goer ved tab-events, beskeder, navigation),
+// naaede alarmen aldrig at fyre. Resultat: offscreen-dokumentet doede, intet
+// genskabte det, og forbindelsen til MCP-serveren kom aldrig tilbage foer
+// nogen genindlaeste extensionen i haanden.
+//
+// Nu oprettes den kun hvis den ikke findes, saa nedtaellingen faar lov at
+// loebe faerdig.
+chrome.alarms.get('ensure-offscreen', (eksisterende) => {
+  if (!eksisterende) {
+    chrome.alarms.create('ensure-offscreen', {
+      periodInMinutes: 1,
+      delayInMinutes: 1,
+    });
+  }
+});
 
-chrome.alarms.create('ensure-offscreen', { periodInMinutes: 1 });
 chrome.alarms.onAlarm.addListener((alarm) => {
   if (alarm.name === 'ensure-offscreen') {
     ensureOffscreen().catch(console.error);