@agent360/browser-mcp 1.28.1 → 1.29.1

package/extension/background.js

@@ -79,7 +79,15 @@ function getSession(port, pid) {
     // 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++;
+    // Havde denne chat en plads foer den slap sin port, og er den stadig ledig, saa faar
+    // den sin egen tilbage — se pladsPrPid. Ellers laveste ledige, som foer.
+    const husket = typeof pid === 'number' ? pladsPrPid.get(pid) : undefined;
+    if (typeof husket === 'number' && !brugte.has(husket)) {
+      nummer = husket;
+    } else {
+      while (brugte.has(nummer)) nummer++;
+    }
+    husketPlads(pid, nummer);
 
     sessions.set(port, {
       tabIds: new Set(),
@@ -93,7 +101,7 @@ function getSession(port, pid) {
   }
   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;
+  if (s.pid == null && typeof pid === 'number') { s.pid = pid; husketPlads(pid, s.nummer); }
   return s;
 }
 
@@ -211,6 +219,8 @@ async function evictOldestTabs(session, justAddedTabId) {
 async function addTabToSession(port, tabId) {
   const session = getSession(port);
   session.tabIds.add(tabId);
+  // Sessionen lever igen — aflys en eventuel port-frigivelse (se tabs.onRemoved).
+  chrome.alarms.clear(`frigiv-${port}`).catch(() => {});
 
   // LRU eviction: når sessionen overstiger cap, luk de ældste tabs.
   if (session.tabIds.size > MAX_TABS_PER_SESSION) {
@@ -247,13 +257,62 @@ async function releaseSession(port) {
   const session = sessions.get(port);
   if (!session) return;
 
+  // ── Bad vi selv om frigivelsen? (FUNDET AF REVIEW 7/9) ────────────────────
+  //
+  // Vejen fra "sessionen er tom" til denne funktion gaar over mindst tre hop:
+  // sendMessage -> offscreen sender terminate og lukker WS -> ws.onclose ->
+  // session_disconnect. Aabner agenten en fane i de ~50 ms undervejs, lukkede
+  // oprydningen herunder DEN fane — paa grundlag af en beslutning der blev truffet
+  // foer fanen fandtes. Det er praecis "agenten holder pause og genoptager"-
+  // scenariet frigivelsen er bygget til at understoette.
+  //
+  // En UVENTET afbrydelse (chatten er vaek) skal stadig lukke fanerne — derfor
+  // skelnes der, i stedet for bare at tjekke om sessionen er tom.
+  // #12: sessionen forsvinder her — dens frist skal med, uanset hvilken vej vi gaar ud.
+  chrome.alarms.clear(`frigiv-${port}`).catch(() => {});
+
+  if (frivilligtFrigivet.delete(port)) {
+    if (session.tabIds.size) {
+      // Sessionen arbejder igen. Behold den, saa naeste binding kan adoptere den
+      // (adoptOrphanedSession finder donorer med samme pid OG faner).
+      persistSessions();
+      return;
+    }
+    sessions.delete(port);
+    persistSessions();
+    return;
+  }
+
   // Detach debugger + close all session tabs
-  const tabIds = [...session.tabIds];
-  for (const tabId of tabIds) {
+  //
+  // #13: fejlene blev slugt her, og `sessions.delete(port)` koerte alligevel. En fane der
+  // ikke KUNNE lukkes blev dermed foraeldreloes: stadig aaben, stadig i en farvet gruppe,
+  // men uden for enhver session — usynlig for list_tabs og aldrig ryddet op. Praeeksisterende,
+  // men v1.29 slipper porte langt oftere, saa stien koeres langt hyppigere end foer.
+  const stadigAabne = new Set();
+  for (const tabId of [...session.tabIds]) {
     debuggerForceDetach(tabId);
     try {
       await chrome.tabs.remove(tabId);
-    } catch {} // tab may already be closed
+      session.tabIds.delete(tabId);
+    } catch {
+      // Fanen kan vaere lukket i forvejen — saa er den vaek, og det er fint. Findes den
+      // stadig, beholder vi den: bedre en session der lever lidt for laenge end en fane
+      // ingen ejer.
+      try {
+        await chrome.tabs.get(tabId);
+        stadigAabne.add(tabId);
+      } catch {
+        session.tabIds.delete(tabId);
+      }
+    }
+  }
+
+  if (stadigAabne.size) {
+    console.warn('[BG] kunne ikke lukke', [...stadigAabne], '— sessionen beholdes saa fanerne ikke strander');
+    session.tabIds = stadigAabne;
+    persistSessions();
+    return;
   }
 
   sessions.delete(port);
@@ -401,7 +460,13 @@ async function debuggerAttach(tabId) {
       lastMsg = 'attach resolved but Chrome shows tab not attached (ghost — page likely mid-reload)';
       try { await chrome.debugger.detach({ tabId }); } catch {}
     } catch (e) {
-      if (e.message?.includes('Already attached')) {
+      // MAALT 31/8 af den nye udvidelses-test: her stod `includes('Already attached')`
+      // med stort A. Chromes faktiske besked er "Another debugger is already attached
+      // to the tab with id: N" — med lille. Tjekket ramte ALDRIG. Resultat: naar en
+      // anden debugger havde fanen (DevTools aabent, en anden udvidelse), blev det
+      // behandlet som en fejl, proevet tre gange, og kastet — i stedet for bare at
+      // bruge den session der allerede fandtes.
+      if (/already attached/i.test(e.message || '')) {
         // Chrome side has session — sync local cache
         debuggerAttached.add(tabId);
         return;
@@ -445,13 +510,26 @@ chrome.debugger.onDetach.addListener((source, reason) => {
 // Side-effectful methods (Input.*, DOM.setFileInputFiles) must NEVER auto-retry:
 // Chrome may detach AFTER processing the input (e.g., keystroke triggered navigation),
 // and a blind retry would double-type or double-click.
+// MAALT 9/9-2026 (fundet af Astra, reproduceret her): `Runtime.evaluate` stod paa listen,
+// fordi de fleste kald er laesninger. Men vi kan ikke afgoere paa metodenavnet om et
+// udtryk MUTERER — og flere af dem goer:
+//   * settle-udtrykket i debuggerClick FYRER reserveloesnings-klikket
+//   * scroll'ens reserveloesning kalder window.scrollBy
+//   * fill skriver i feltet gennem evalAttached
+// Reproduktion: cdpSend(1,'Runtime.evaluate',{expression:'window.tael++'}) med en
+// detach-fejl koerte udtrykket FIRE gange. Paa en SPA hvor debuggeren falder af, kunne
+// det altsaa lande fire klik — paa en knap der maaske bestiller noget.
+//
+// Vi kan ikke skelne, saa standarden skal vaere sikker. Falder debuggeren af midt i en
+// evaluering, faar kalderen fejlen og kan selv beslutte om det er forsvarligt at gentage.
+// Prisen er en tabt gentagelse paa anti-automatiserings-sider; alternativet er et
+// dobbeltklik, og de to ting er ikke lige slemme.
 const RETRYABLE_CDP_METHODS = new Set([
   'DOM.getDocument',
   'DOM.querySelector',
   'DOM.querySelectorAll',
   'DOM.focus',
   'DOM.describeNode',
-  'Runtime.evaluate',
   'Runtime.enable',
   'Page.captureScreenshot',
   'Page.enable',
@@ -463,6 +541,86 @@ const RETRYABLE_CDP_METHODS = new Set([
 // CDP wrapper with auto-recovery: re-attaches on detach errors.
 // For read-only methods (whitelist above), retries once after re-attach.
 // For side-effectful methods, only re-attaches and throws — caller must decide.
+// MAALT 8/9-2026: `Input.dispatchMouseEvent` med mouseWheel indfrier ALDRIG sit loefte.
+// `browser_scroll` med pixels ramte derfor serverens 30-sekunders-loft 6 kald ud af 6,
+// paa baade en kort og en lang side — og den `window.scrollBy` der er skrevet til netop
+// det tilfaelde, ligger i et `catch` og kunne aldrig naas. En haenger er ikke en exception.
+// Fristen findes for at reserveloesningen kan naas. Alt der HAR en reserveloesning skal
+// kunne naas via en frist, ikke kun via en fejl.
+// Foerste udgave satte 1.500 ms paa ALT. Astra fandt 9/9 at det indfoerte en ny fejlklasse:
+// dialog-ventetider bruger 3.000 ms, og et Page.captureScreenshot paa en tung side kan
+// lovligt tage laengere. Fristen skar dem over, og skaermbilledets reserveloesning blev
+// dermed naaet i almindelig drift — se rettelse B nedenfor.
+//
+// Den hang der blev MAALT var Input.dispatchMouseEvent med mouseWheel, som aldrig indfrier
+// sit loefte. Laesekald har i forvejen deres egne ydre frister (evaluerTaalmodigt).
+// Derfor: kort frist paa input-kald, og en rundhaandet bagstopper paa resten — stadig under
+// serverens 30 s, saa kalderens reserveloesning kan naas.
+const CDP_FRIST_INPUT_MS = 1500;
+const CDP_FRIST_MS = 8000;
+// MAALT 9/9 af reviewet: ét loft paa alt braekker tre ting. Et skaermbillede paa en tung
+// side bruger lovligt mere end 8 s; `execute_script` med awaitPromise venter paa BRUGERENS
+// egen kode, som serveren giver 30 s; og et enkelt tastetryk paa en side med validering
+// pr. anslag kan lovligt overskride input-fristen. Fristen skal derfor kende kaldet.
+const CDP_FRIST_TUNG_MS = 20000;   // under serverens 30 s, men over alt lovligt
+
+function cdpFrist(method, params) {
+  const m = String(method);
+  // Brugerens egen kode maa vente: awaitPromise betyder "vent paa dette loefte".
+  if (m === 'Runtime.evaluate' && params && params.awaitPromise) return CDP_FRIST_TUNG_MS;
+  if (m === 'Page.captureScreenshot' || m === 'Network.getResponseBody') return CDP_FRIST_TUNG_MS;
+  return m.startsWith('Input.') ? CDP_FRIST_INPUT_MS : CDP_FRIST_MS;
+}
+
+// Skaermbilledet har et budget for HELE kaeden, ikke kun pr. kald.
+// MAALT 11/9 af Astra (sign-off, R5 F8): standardoptagelsen hang og koblede foerst fra efter 19 s. cdpSend gentog den,
+// fordi den staar som sikker at gentage, og billedet kom efter ca. 38 s - serveren havde opgivet ved 30 s. I 1.29.0
+// sendte en frist paa 8 s kaldet videre til fromSurface:false, som svarede paa et halvt sekund.
+// Standardoptagelsen faar derfor 10 s. Reserven faar resten af budgettet, saa svaret naar frem foer serverens frist.
+// MAALT 11/9 af Fable (e2e-review): haenger BEGGE optagelser, haevede 1.29.0 vinduet og leverede et billede efter 16,7 s.
+// En frist afskar den sidste udvej her, saa der kom intet billede. Budgettet reserverer derfor haevMs til den haevede runde.
+//
+// MAALT 12/9 af Astra (tredje runde paa samme sted): en gentilslutning paa 12,5 s betoed at kandidaten opgav efter 26,9 s,
+// hvor 1.29.0 leverede et billede efter 29,2 s. Aarsagen var ikke logikken, men TALLET: 26 s var valgt frit, ikke udledt.
+// Hver runde fandt et nyt scenarie i de 4 sekunder vi gav bort. Budgettet er derfor nu udledt af det eneste tal der
+// betyder noget - serverens egen frist pr. kald (sendToExtension i mcp-server/index.js) - minus den tid svaret skal
+// bruge paa at komme tilbage gennem broen. Aendrer serverens frist sig, foelger budgettet med.
+const SERVER_FRIST_MS = 30000;      // sendToExtension(..., timeoutMs = 30000) i mcp-server/index.js
+// MAALT 12/9 af Astra: hjemrejsen for en skaermbillede-stor nyttelast over den lokale WebSocket er 84-154 ms
+// (0,5 / 2 / 8 MB, tre maalinger hver). 1500 ms var 10x det - altsaa endnu et frit valgt tal i den regel der lige var
+// lukket. 500 ms er tre gange det maalte og krymper baandet, hvor 1.29.0 leverer og vi ikke goer, fra ~1,35 s til ~0,35 s.
+const SVARETS_HJEMREJSE_MS = 500;   // udvidelse -> offscreen -> WebSocket -> server
+function skaermbilledeFrister() {
+  return { foersteMs: 10000, samletMs: SERVER_FRIST_MS - SVARETS_HJEMREJSE_MS, haevMs: 8000 };
+}
+
+// wait_for_network har samme loft hos serveren (30 s). MAALT 11/9 af Astra (e2e-review): svaret kom efter 13 s, body-kaldet
+// fik CDP_FRIST_TUNG_MS (20 s) oveni, og serveren opgav ved 30 s, hvor 1.29.0 svarede efter 21 s med body:null.
+// Hele vaerktoejet har derfor ét budget, og body-kaldet faar kun det der er tilbage.
+// Astra (efterproevning af c826f63): budgettet skar en body over der kom efter 27 s + 2 s, som 1.29.0 leverede efter 29 s.
+// Body-kaldet faar derfor aldrig kortere tid end 1.29.0's frist (CDP_FRIST_MS) og aldrig mere end CDP_FRIST_TUNG_MS.
+// MAALT 12/9 af Astra: her stod 28000 haardkodet - det SAMME frie tal som skaermbilledets budget lige var sluppet af med.
+// Begge budgetter udledes nu af serverens egen frist, saa reglen gaelder hele vejen og ikke kun dér hvor den blev fundet.
+function netvaerkFrister() {
+  return { budgetMs: SERVER_FRIST_MS - SVARETS_HJEMREJSE_MS, bodyMinMs: CDP_FRIST_MS, bodyMaxMs: CDP_FRIST_TUNG_MS };
+}
+
+function cdpMedFrist(tabId, method, params) {
+  let ur;
+  const frist = cdpFrist(method, params);
+  return Promise.race([
+    chrome.debugger.sendCommand({ tabId }, method, params),
+    new Promise((_, afvis) => {
+      // MAALT 11/9 (raa CDP-proeve i Chrome for Testing): Chrome leverer ikke Input.* til en fane i baggrunden.
+      // Kaldet haenger, og efter aktivering svarer det paa millisekunder. Fejlen siger det, saa agenten ved hvad den goer.
+      const hint = String(method).startsWith('Input.')
+        ? ' (fanen er sandsynligvis i baggrunden - Chrome leverer ikke mus og taster til en fane der ikke er aktiv; kald browser_switch_tab og proev igen)'
+        : '';
+      ur = setTimeout(() => afvis(new Error(`CDP svarede ikke inden ${frist} ms: ${method}${hint}`)), frist);
+    }),
+  ]).finally(() => clearTimeout(ur));
+}
+
 async function cdpSend(tabId, method, params = {}) {
   await debuggerAttach(tabId);
   let lastMsg = '';
@@ -471,7 +629,7 @@ async function cdpSend(tabId, method, params = {}) {
   // where Chrome re-detaches between attach and command execution.
   for (let attempt = 0; attempt < 4; attempt++) {
     try {
-      return await chrome.debugger.sendCommand({ tabId }, method, params);
+      return await cdpMedFrist(tabId, method, params);
     } catch (e) {
       const msg = e?.message || String(e);
       const isDetachError =
@@ -504,6 +662,27 @@ async function cdpSend(tabId, method, params = {}) {
 // 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();
+// Porte hvor VI selv har bedt serveren slippe porten, fordi sessionen var tom.
+// Skelnen betyder alt i releaseSession: en frivillig frigivelse maa aldrig lukke
+// faner, mens en uventet afbrydelse (chatten er vaek) netop skal rydde op.
+const frivilligtFrigivet = new Set();
+// Hvilken plads en chat sidst havde, husket paa dens pid — ikke paa porten.
+//
+// MAALT 8/9 (#17): siden porten slippes naar en session er faerdig, slettes sessionen.
+// Kommer chatten tilbage, faar den det laveste LEDIGE nummer — saa en chat der var
+// "Claude 3" vender tilbage som "Claude 1" i en anden farve, og brugeren kan ikke
+// genkende sin egen fanegruppe. Identiteten hoerer til chatten, ikke til porten.
+//
+// Garantien er praecis "dit gamle nummer HVIS det er ledigt". Er det taget, vinder den
+// nulevende session — ellers ville vi genindfoere den navnekollision som lavest-ledige-
+// nummer blev indfoert for at loese.
+const pladsPrPid = new Map();
+function husketPlads(pid, nummer) {
+  if (typeof pid !== 'number') return;
+  pladsPrPid.set(pid, nummer);
+  // Kortet maa ikke vokse i det uendelige paa en langtlevende worker.
+  if (pladsPrPid.size > 60) pladsPrPid.delete(pladsPrPid.keys().next().value);
+}
 
 // ── Armerede dialog-haandterere, pr. fane ──────────────────────────────────────
 // MAALT 22/8 af flowtesten: handle_dialog var ubrugelig som den var skrevet. Den
@@ -536,21 +715,71 @@ function afvaebnDialog(tabId, grund) {
   if (grund && a.opfyld) a.opfyld({ ok: false, error: grund });
 }
 
+// Fylder sessions-kortet fra lageret UDEN at filtrere paa om fanerne stadig findes.
+//
+// `restoreSessions()` dropper sessioner uden GYLDIGE faner (`validTabIds.size > 0`), og i
+// `tabs.onRemoved` er den fane vi lige har mistet netop den der ville goere sessionen
+// ugyldig. Bruger man restoreSessions dér, forsvinder praecis den session man skal handle
+// paa. Samme faelde som i alarm-lytteren, og derfor samme svar: laes lageret raat.
+async function hydrerSessionerRaat() {
+  if (sessions.size) return;
+  const { sessions: gemte } = await chrome.storage.local.get({ sessions: {} });
+  for (const [port, d] of Object.entries(gemte)) {
+    const p = Number(port);
+    if (sessions.has(p)) continue;
+    sessions.set(p, {
+      tabIds: new Set(d.tabIds || []),
+      activeTabId: d.activeTabId ?? null,
+      groupId: d.groupId ?? null,
+      color: d.color,
+      label: d.label,
+      nummer: d.nummer ?? null,
+      pid: d.pid ?? null,
+    });
+  }
+}
+
 chrome.tabs.onRemoved.addListener((tabId) => {
   afvaebnDialog(tabId, 'fanen blev lukket foer der kom en dialog');
   const lukketAfAgenten = agentLukkedeFaner.delete(tabId);
   debuggerAttached.delete(tabId);
+  // MAALT 8/9 (#15): loekken herunder loeb SYNKRONT paa `sessions`. Vaekker eventet en
+  // suspenderet service-worker, er kortet tomt, loekken koerer nul gange, og hverken
+  // nedlukningen eller fristen bliver sat — porten holdes saa til 4-timers-tomgangen.
+  // Agentens egen close_tab ramte det ikke (den kommer som mcp_command, der vaekker og
+  // gendanner foerst). Det var specifikt MENNESKET der lukkede den sidste fane, senere.
+  (async () => {
+  await hydrerSessionerRaat();
   for (const [port, session] of sessions) {
     if (!session.tabIds.has(tabId)) continue;
     session.tabIds.delete(tabId);
     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.
+      frivilligtFrigivet.add(port);
       chrome.runtime.sendMessage({ type: 'terminate_mcp_session', port }).catch(() => {});
+    } else if (session.tabIds.size === 0) {
+      // ── Agenten lukkede selv sin sidste fane (MAALT 7/9-2026) ────────────────
+      // Her stod der intet, og det var med vilje: en agent der lukker en fane midt i
+      // et forloeb skal ikke miste browseren. Men serverens EGEN instruks siger til
+      // hver eneste agent: "ALWAYS close tabs when done". Hver velopdragen chat endte
+      // altsaa med at holde sin port til 4-timers-tomgangen udloeb — den dokumenterede
+      // god-praksis slog oprydningen ihjel, og 20 porte kunne staa optaget af chats
+      // der for laengst var faerdige.
+      //
+      // Nu: fem minutters henstand. Kommer der en ny fane inden da, aflyses den
+      // (se getSessionTab). Sker der intet, bedes serveren slippe porten — den DOER
+      // ikke, saa chatten kan hente browseren tilbage naar som helst.
+      //
+      // chrome.alarms og ikke setTimeout: en MV3-service-worker suspenderes, og en
+      // timer ville forsvinde med den.
+      chrome.alarms.create(`frigiv-${port}`, { delayInMinutes: 5 });
+      persistSessions();
     } else {
       persistSessions();
     }
   }
+  })().catch(() => {});
 });
 
 // Physical-key `code` for a character, US layout. We used to build this as
@@ -585,18 +814,9 @@ 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 } : {}),
-    });
+    await tastParAttached(tabId,
+      { text: char, key: char, ...(code ? { code } : {}), unmodifiedText: char },
+      { 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
@@ -653,15 +873,59 @@ 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; });
+    .catch((e) => { faerdig = true; return { __fejl: String(e?.message || e) }; });
   await Promise.race([kald, new Promise((r) => setTimeout(r, ms))]);
   if (faerdig) return kald;
-  return { result: { value: { landed: true, fallbackFired: false, rendererSvarede: false } } };
+  return { result: { value: { landed: true, fallbackFired: false, rendererSvarede: false, observeret: false } } };
+}
+
+// Én regel for om et klik landede - brugt af click, click_xy og select_option. Astra, tredje runde:
+// select_option havde stadig den gamle ("ikke falsk" = landet), saa et uvist klik blev til ok:true.
+function klikLandede(r) {
+  return r?.landed === true || r?.detached === true;
+}
+
+// Teksten der foelger med et uvist klik. Staar ét sted, fordi den skal vaere ens for click, click_xy og select_option -
+// tre kaldesteder med den samme regel har foer drevet fra hinanden (select_option havde den gamle i to udgaver).
+const UVIST_NOTE = 'Klikket blev sendt, og siden aendrede sig paa mousedown - men ikke af selve klikket. Det kan vaere en ripple, og det kan vaere en menu der aabner paa mousedown. Tjek tilstanden foer du klikker igen: et klik nummer to lukker en menu der allerede er aaben.';
+const UVERIFICERET_NOTE = 'Museknappen blev sendt, men siden kunne ikke laeses bagefter (opslaget fejlede, og siden navigerede ikke). ' +
+  'Klikket kan vaere landet. Tjek tilstanden foer du klikker igen.';
+
+// MAALT 12/9 af Astra: der er TO uvisheds-kanaler - `uvist` (kun mousedown aendrede noget) og `uverificeret`
+// (settle-opslaget fejlede uden navigation, men museknappen ER sendt). Rettelsen roerte kun den foerste, saa den anden
+// gav stadig et bart ok:false hvor 1.29.0 gav ok:true - og et bart nej faar agenten til at klikke igen.
+// Betingelsen spoerger derfor paa landed === null, ikke paa ét flag: en fremtidig tredje kanal er daekket fra dag ét.
+function uvisVurdering(r) {
+  if (!r || r.landed !== null) return null;
+  if (r.uvist) return { maaske_landet: true, note: UVIST_NOTE };
+  if (r.uverificeret) return { maaske_landet: true, note: UVERIFICERET_NOTE };
+  return { maaske_landet: true, note: 'Handlingen blev sendt, men virkningen kunne ikke bekraeftes. Tjek tilstanden foer du gentager den.' };
+}
+
+// MAALT 10/9 af Astra (anden runde): et settle-opslag der FEJLEDE gav null, og null blev til ok:true.
+// Men den hyppigste grund til at opslaget fejler er at klikket navigerede - det er en virkning, og agenten
+// maa ikke faa at vide at den skal klikke igen.
+// Tredje runde: "detached", "closed" og "Cannot find" er IKKE bevis for navigation - afkobling sker ogsaa
+// naar nogen aabner DevTools. Bevis er nu: fanen er lukket, adressen er skiftet, eller JavaScript-konteksten
+// blev revet ned (det sker kun naar dokumentet blev udskiftet). Alt andet er uvist og siges som uvist.
+async function tolkManglendeSettle(tabId, settle, urlFoer) {
+  const fejl = settle?.__fejl || 'settle-opslaget gav intet svar';
+  const fane = await chrome.tabs.get(tabId).catch(() => null);
+  const urlEfter = fane?.url ?? null;
+  const kontekstVaek = /Execution context was destroyed|Cannot find context with specified id|Inspected target navigated/i.test(fejl);
+  if (!fane || (urlFoer && urlEfter && urlEfter !== urlFoer) || kontekstVaek) {
+    return { landed: false, fallbackFired: false, detached: true, navigerede: true };
+  }
+  return { landed: null, fallbackFired: false, uverificeret: true, fejl };
 }
 
 async function debuggerClick(tabId, x, y) {
   await debuggerAttach(tabId);
+  // Er museknappen sendt ned, kan klikket vaere landet - saa maa en fejl bagefter ikke fore til et klik til.
+  let trykSendt = false;
   try {
+    // Adressen foer klikket - et skift bagefter er bevis for en virkning (se tolkManglendeSettle).
+    const urlFoer = (await chrome.tabs.get(tabId).catch(() => null))?.url ?? null;
     // 0. Capture the DEEPEST target element under the point BEFORE dispatching.
     //    Web-components (Google Ads <button-panel>, Material Web) keep their real
     //    <button> inside an (open) shadow root, so we pierce shadow roots to reach
@@ -704,52 +968,135 @@ 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 dispatchTaalmodigt(tabId, {
-      type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 1,
-    });
-    await new Promise(r => setTimeout(r, 30));
-    await dispatchTaalmodigt(tabId, {
-      type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 1,
-    });
+    trykSendt = true;
+    // Astra, tredje runde: fejlede mousePressed EFTER at vaere leveret, blev mouseReleased aldrig sendt,
+    // og siden stod tilbage med knappen nede (drag-tilstand). Knappen slippes nu altid.
+    let trykFejl = null;
+    try {
+      await dispatchTaalmodigt(tabId, {
+        type: 'mousePressed', x, y, button: 'left', buttons: 1, clickCount: 1,
+      });
+      await new Promise(r => setTimeout(r, 30));
+    } catch (e) { trykFejl = e; }
+    try {
+      await dispatchTaalmodigt(tabId, {
+        type: 'mouseReleased', x, y, button: 'left', buttons: 0, clickCount: 1,
+      });
+    } catch (e) { trykFejl = trykFejl || e; }
+    if (trykFejl) throw trykFejl;
     // 3. Framework fallback — only if the captured target is STILL connected (i.e.
     //    the trusted click in step 2 did not already handle it). Settle delay lets
     //    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));
+    // MAALT 9/9-2026: oprydningen (removeEventListener + delete) laa FOER reserveloesningen
+    // fyrede. Derfor kunne intet observere om det syntetiske klik virkede, og udtrykket
+    // svarede landed:false som et GAET. Paa en div-baseret dropdown betoed det
+    // {ok:true, landed:false} og en menu der aldrig aabnede — issue #19.
+    // Nu staar lytteren stadig paa document mens reserveloesningen fyrer, og laeses bagefter:
+    // det er forskellen paa en maaling og en antagelse. Der ryddes op paa hver udgang.
+    // NB: ingen backticks i udtrykket herunder — det ER et template literal.
     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 { 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 ryd = () => {
+          try { window.__bmcpClickListener && document.removeEventListener('click', window.__bmcpClickListener, true); } catch (e) {}
+          try { delete window.__bmcpClickTarget; delete window.__bmcpClicked; delete window.__bmcpClickListener; } catch (e) {}
+        };
+        // Et billigt fingeraftryk af det et klik plejer at aendre: antal noder, synlig tekst,
+        // adressen, og om noget er aabnet/valgt. Bevidst groft — det skal kunne tages to gange
+        // paa faa millisekunder, ikke beskrive siden.
+        // MAALT 11/9 af Astra (R5 F6): tekst og feltvaerdier blev talt i LAENGDE, saa AAAA -> BBBB var
+        // usynlig, og et klik der virkede blev meldt som fejl. Nu hashes indholdet (FNV-1a, 32 bit).
+        const hash = (s) => {
+          let x = 2166136261;
+          for (let i = 0; i < s.length; i++) { x ^= s.charCodeAt(i); x = Math.imul(x, 16777619); }
+          return (x >>> 0).toString(36);
+        };
+        const aftryk = () => {
+          try {
+            return document.querySelectorAll('*').length + '|' +
+                   hash(document.body ? String(document.body.innerText) : '') + '|' +
+                   location.href + '|' +
+                   document.querySelectorAll('[aria-expanded="true"],[aria-selected="true"],[open],.open,.active').length + '|' +
+                   // Astra, anden runde: en afkrydsning eller en feltvaerdi aendrer hverken noder, tekst eller
+                   // adresse - saa et klik der VIRKEDE blev meldt som fejl, og et nyt klik ville fortryde det.
+                   document.querySelectorAll('input:checked,option:checked').length + '|' +
+                   hash(Array.from(document.querySelectorAll('input,textarea,select')).map((e) => String(e.value || '')).join(''));
+          } catch (e) { return 'aftryk-fejlede'; }
+        };
+        if (landed) { ryd(); return { landed: true, fallbackFired: false }; }   // FIX-13: trusted click already landed — do NOT double-fire
+        if (el === null) { ryd(); return { landed: false, fallbackFired: false, intetMaal: true }; }   // intet element under punktet (fx uden for vinduet) - ingen virkning
+        if (!el || !el.isConnected) { ryd(); return { landed: false, fallbackFired: false, detached: true }; }   // already navigated/handled — don't double-fire
+        const foerAftryk = aftryk();
         const opts = { bubbles: true, cancelable: true, composed: true, view: window, clientX: ${x}, clientY: ${y} };
-        try { el.dispatchEvent(new PointerEvent('pointerdown', opts)); } catch (e) {}
+        // Samme moenster som script-klikket (Astra 11/9): en PointerEvent uden pointerType er ikke en mus.
+        const mus = { ...opts, pointerType: 'mouse', isPrimary: true, pointerId: 1, button: 0 };
+        try { el.dispatchEvent(new PointerEvent('pointerdown', { ...mus, buttons: 1 })); } catch (e) {}
         el.dispatchEvent(new MouseEvent('mousedown', opts));
-        try { el.dispatchEvent(new PointerEvent('pointerup', opts)); } catch (e) {}
+        try { el.dispatchEvent(new PointerEvent('pointerup', { ...mus, buttons: 0 })); } catch (e) {}
         el.dispatchEvent(new MouseEvent('mouseup', opts));
-        el.dispatchEvent(new MouseEvent('click', opts));
+        // MAALT 10/9 i en rigtig browser: her stod BEGGE — dispatchEvent('click') OG el.click().
+        // Det er to klik-haendelser. Paa alt hvad der skifter tilstand (dropdowns, faneblade,
+        // afkrydsningsfelter, harmonikaer) aabner det foerste og det andet lukker igen, saa
+        // resultatet er intet. Det er aarsagen til at issue #19's div-dropdown "aldrig aabnede":
+        // den aabnede og lukkede inde i den samme reserveloesning.
+        //   ét klik:  aftryk 11|53|…|0 -> 11|69|…|1   (menuen aaben)
+        //   to klik:  aftryk 11|53|…|0 -> 11|53|…|0   (tilbage ved start)
+        // el.click() foretraekkes, fordi den ogsaa udloeser elementets aktiverings-adfaerd
+        // (foelg link, skift afkrydsning) — det goer en syntetisk MouseEvent ikke paalideligt.
+        // MAALT 11/9 af Astra (R5 F5): aftrykket til afgoerelsen herunder var foerAftryk fra FOER mousedown.
+        // En ripple-node fra mousedown lignede derfor en virkning af el.click(), React blev sprunget over,
+        // og svaret blev landed:true med nul handling. Afgoerelsen maaler nu kun hvad el.click() gjorde.
+        const foerKlik = aftryk();
         if (typeof el.click === 'function') el.click();
+        else el.dispatchEvent(new MouseEvent('click', opts));
+
+        // MAALT 10/9 af Astra (anden runde): React-fiberens onClick blev kaldt UBETINGET efter el.click() -
+        // men el.click() udloeser allerede Reacts handler. To koersler, og en toggle endte hvor den startede.
+        // Framework-vejene er til elementer hvor det native klik INGEN virkning gav.
+        if (aftryk() === foerKlik) {
+          // React fiber fallback — find and call onClick handler directly
+          const fiberKey = Object.keys(el).find(k => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'));
+          if (fiberKey) {
+            let fiber = el[fiberKey];
+            for (let i = 0; i < 10 && fiber; i++) {
+              if (fiber.memoizedProps?.onClick) { fiber.memoizedProps.onClick(new MouseEvent('click', {bubbles:true})); break; }
+              fiber = fiber.return;
+            }
+          }
 
-        // React fiber fallback — find and call onClick handler directly
-        const fiberKey = Object.keys(el).find(k => k.startsWith('__reactFiber') || k.startsWith('__reactInternalInstance'));
-        if (fiberKey) {
-          let fiber = el[fiberKey];
-          for (let i = 0; i < 10 && fiber; i++) {
-            if (fiber.memoizedProps?.onClick) { fiber.memoizedProps.onClick(new MouseEvent('click', {bubbles:true})); break; }
-            fiber = fiber.return;
+          // Angular Material fallback — ripple + internal handlers
+          const ngKey = Object.keys(el).find(k => k.startsWith('__ng'));
+          if (ngKey || el.getAttribute('ng-click') || el.getAttribute('(click)')) {
+            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));
           }
         }
 
-        // Angular Material fallback — ripple + internal handlers
-        const ngKey = Object.keys(el).find(k => k.startsWith('__ng'));
-        if (ngKey || el.getAttribute('ng-click') || el.getAttribute('(click)')) {
-          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 };
+        // Lytteren kan IKKE bruges her. Den udloeses af enhver dispatch paa maalet, og
+        // reserveloesningen dispatcher netop paa maalet — saa flaget ville vaere sandt fordi
+        // VI sendte noget, ikke fordi siden reagerede. Reproduceret 9/9 mod et <div> uden
+        // nogen handler: foer=false, efter=true.
+        // Derfor maales sidens REAKTION i stedet, med samme aftryks-greb som select_option
+        // allerede bruger: aendrede noget sig af det et klik plejer at aendre?
+        // MAALT 12/9 af Fable (e2e runde 3): her sammenlignedes med aftrykket fra FOER mousedown.
+        // Rettelsen af R5 F5 ovenfor gjaldt kun HVILKEN vej der blev proevet, ikke hvad vi SVAREDE. Uden en framework-vej
+        // at falde tilbage paa gav en ripple derfor stadig landed:true med nul handling.
+        // Tre udfald, ikke to: aendrede klikket (eller framework-vejen) noget, er det landet. Aendrede kun mousedown
+        // noget, ved vi det ikke - det kan vaere en ripple, men ogsaa en menu der aabner paa mousedown. Saa siges der
+        // hverken ja eller nej: landed null bliver til maaske_landet hos kalderen, med den maalte tilstand.
+        const efterAftryk = aftryk();
+        const klikketVirkede = efterAftryk !== foerKlik;
+        const kunMousedown = !klikketVirkede && foerKlik !== foerAftryk;
+        ryd();
+        return {
+          landed: kunMousedown ? null : klikketVirkede,
+          ...(kunMousedown ? { uvist: true } : {}),
+          fallbackFired: true, aftrykFoer: foerAftryk, aftrykEfter: efterAftryk,
+        };
       })()`,
     });
     const vaerdi = settle?.result?.value ?? null;
@@ -766,7 +1113,10 @@ async function debuggerClick(tabId, x, y) {
         dialogLoefter.delete(tabId);
       }
     }
-    return vaerdi;
+    return vaerdi ?? await tolkManglendeSettle(tabId, settle, urlFoer);
+  } catch (e) {
+    if (trykSendt && e && typeof e === 'object') e.trykSendt = true;
+    throw e;
   } finally {
     await debuggerDetach(tabId);
   }
@@ -798,20 +1148,21 @@ async function evalAttached(tabId, expression) {
   return result.result?.value;
 }
 
+// En tast ned og op igen - og op igen UANSET hvad. MAALT 10/9 af Astra (anden runde): press_key fik
+// keyUp-altid i foerste runde, men de tre hjaelpere der ogsaa sender taster gjorde ikke. Timede et
+// keyDown ud efter at det VAR landet, forlod hjaelperen funktionen foer sit keyUp, og tasten sad fast
+// for siden. Et fastsiddende Cmd goer det naeste tastetryk til en genvej.
+async function tastParAttached(tabId, ned, op) {
+  let fejl = null;
+  try { await cdpSend(tabId, 'Input.dispatchKeyEvent', { type: 'keyDown', ...ned }); } catch (e) { fejl = e; }
+  try { await cdpSend(tabId, 'Input.dispatchKeyEvent', { type: 'keyUp', ...op }); } catch (e) { fejl = fejl || e; }
+  if (fejl) throw fejl;
+}
+
 // 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',
-  });
+  await tastParAttached(tabId, { key: 'a', code: 'KeyA', modifiers: SELECT_ALL_MODS }, { key: 'a', code: 'KeyA' });
+  await tastParAttached(tabId, { key: 'Backspace', code: 'Backspace' }, { key: 'Backspace', code: 'Backspace' });
 }
 
 async function debuggerFill(tabId, selector, value) {
@@ -847,6 +1198,37 @@ async function debuggerFill(tabId, selector, value) {
   try {
     await clearFieldAttached(tabId);
 
+    // ── Blev feltet FAKTISK tomt? (MAALT 8/9) ────────────────────────────────
+    //
+    // `clearFieldAttached` sender Cmd/Ctrl+A og Backspace som aegte tastetryk. Paa et
+    // React-styret felt tommer det ikke: maalt paa forbrugeragenten.dk/penge-tilbage gav
+    // to fill-kald efter hinanden vaerdien "test@example.dkanden@example.dk" — begge kald
+    // svarede ok:true. Vaerktoejet meldte succes og gjorde noget andet end det lovede.
+    //
+    // Et fill paa et TOMT felt var rent i samme maaling, saa fejlen sidder alene her.
+    // Derfor: laes tilbage, og ryd med den vej der virker paa styrede felter hvis
+    // tastetrykkene ikke slog igennem. Vi gaetter ikke paa hvorfor — vi tjekker.
+    const restVaerdi = await evalAttached(tabId, `
+      (function() {
+        const el = document.activeElement;
+        return el && 'value' in el ? el.value : '';
+      })()
+    `);
+    if (restVaerdi) {
+      await evalAttached(tabId, `
+        (function() {
+          const el = document.activeElement;
+          if (!el || !('value' in el)) return false;
+          const proto = el.tagName === 'TEXTAREA' ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+          const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+          if (setter) setter.call(el, ''); else el.value = '';
+          el.dispatchEvent(new Event('input', { bubbles: true }));
+          el.dispatchEvent(new Event('change', { bubbles: true }));
+          return true;
+        })()
+      `);
+    }
+
     // 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
@@ -918,11 +1300,41 @@ async function scriptingClick(tabId, selector) {
         }
         if (!el) return { ok: false, reason: 'not_found' };
         el.scrollIntoView({ block: 'center', behavior: 'instant' });
-        const opts = { bubbles: true, cancelable: true, view: window };
+        // Sign-off 11/9 (Astra og Fable, begge reproduceret): paa en baggrundsfane blev et klik der krævede isTrusted,
+        // eller kun lyttede paa pointerdown, meldt ok:true uden nogen virkning. Klikket maaler nu sidens reaktion med
+        // samme aftryk og samme regel som debuggerens reserve (debuggerClick) - ingen backticks herinde.
+        const hash = (s) => {
+          let x = 2166136261;
+          for (let i = 0; i < s.length; i++) { x ^= s.charCodeAt(i); x = Math.imul(x, 16777619); }
+          return (x >>> 0).toString(36);
+        };
+        const aftryk = () => {
+          try {
+            return document.querySelectorAll('*').length + '|' +
+                   hash(document.body ? String(document.body.innerText) : '') + '|' +
+                   location.href + '|' +
+                   document.querySelectorAll('[aria-expanded="true"],[aria-selected="true"],[open],.open,.active').length + '|' +
+                   document.querySelectorAll('input:checked,option:checked').length + '|' +
+                   hash(Array.from(document.querySelectorAll('input,textarea,select')).map((e) => String(e.value || '')).join(' '));
+          } catch (e) { return 'aftryk-fejlede'; }
+        };
+        const opts = { bubbles: true, cancelable: true, composed: true, view: window };
+        // Et rigtigt klik sender pointerdown foer mousedown; Radix/shadcn aabner paa pointerdown.
+        // MAALT 11/9 af Astra (efterproevning af 9814636): uden pointerType ("") handlede en side der reagerer paa ikke-mus-
+        // pointere OG paa click to gange. En rigtig mus sender pointerType "mouse".
+        const mus = { ...opts, pointerType: 'mouse', isPrimary: true, pointerId: 1, button: 0 };
+        try { el.dispatchEvent(new PointerEvent('pointerdown', { ...mus, buttons: 1 })); } catch (e) {}
         el.dispatchEvent(new MouseEvent('mousedown', opts));
+        try { el.dispatchEvent(new PointerEvent('pointerup', { ...mus, buttons: 0 })); } catch (e) {}
         el.dispatchEvent(new MouseEvent('mouseup', opts));
+        // Aftrykket tages lige foer el.click(). MAALT 11/9 af Astra (e2e-review): taget foer mousedown blev en ripple klikbevis
+        // (ok:true, nul handlinger; 1.29.0: fejl). En side der reagerer paa pointerdown, bliver derfor aerligt uvist.
+        const foer = aftryk();
         el.click();
-        return { ok: true, tag: el.tagName };
+        // Maales i samme oejeblik som klikket. Astra (efterproevning af c1496d4): en anden maaling 200 ms senere gjorde et
+        // uafhaengigt ur til klikbevis og et klik der navigerede i ventetiden til en fejl. En sen React-opdatering giver
+        // derfor landed:false og maaske_landet - aerligt, aldrig en falsk succes.
+        return { ok: true, tag: el.tagName, landed: aftryk() !== foer, detached: el.isConnected === false };
       },
       args: [selector],
     });
@@ -1156,6 +1568,20 @@ async function offscreenSvarer() {
 const MAX_OFFSCREEN_GENSKAB = 3;
 const OFFSCREEN_PAUSE_MS = 10 * 60 * 1000;
 
+// Et omraade paa mere end dette ville faa HVER brugers browser til at probe tusindvis af porte hvert andet sekund.
+const PORTE_MAX_SPAEND = 200;
+/** Laeser et alternativt portomraade fra chrome.storage.local. Ugyldigt = standarden (9876-9895) staar. */
+async function portOmraadeFraLager() {
+  try {
+    const { bmcpPorte } = await chrome.storage.local.get({ bmcpPorte: null });
+    const m = /^(\d{4,5})-(\d{4,5})$/.exec(String(bmcpPorte ?? ''));
+    if (!m) return null;
+    const fra = Number(m[1]), til = Number(m[2]);
+    if (fra < 1024 || til > 65535 || til < fra || til - fra >= PORTE_MAX_SPAEND) return null;
+    return fra + '-' + til;
+  } catch { return null; }
+}
+
 async function ensureOffscreen() {
   const findes = await chrome.offscreen.hasDocument();
 
@@ -1213,8 +1639,15 @@ async function ensureOffscreen() {
   // baerer den aeldre version, hvilket er praecis den skelnen tjekket skal bruge.
   let minVersion = '';
   try { minVersion = chrome.runtime.getManifest().version; } catch {}
+  // Portomraadet foelger samme vej som versionen. MAALT 12/9 af Astra: serveren sender kun til den NYESTE forbundne
+  // udvidelse, saa en testbrowser paa de samme porte bliver "nyeste" for hver eneste koerende chats server. Et
+  // omraade i chrome.storage.local lader én profil koere isoleret - og fordi det er en VAERDI og ikke en kodeaendring,
+  // er repoets filer byte-identiske, og udgivelsens kode-aftryk er uroert. (Mit foerste forslag, at flytte portene
+  // til manifestet, ville have fjernet dem fra aftrykket - Astra maalte at de ligger i offscreen.js, som hashes.)
+  const porteParam = await portOmraadeFraLager();
   await chrome.offscreen.createDocument({
-    url: 'offscreen.html' + (minVersion ? '?v=' + encodeURIComponent(minVersion) : ''),
+    url: 'offscreen.html' + (minVersion ? '?v=' + encodeURIComponent(minVersion) : '')
+         + (porteParam ? (minVersion ? '&' : '?') + 'porte=' + porteParam : ''),
     reasons: ['WORKERS'],
     justification: 'Maintain persistent WebSocket connection to local MCP server',
   });
@@ -1224,22 +1657,42 @@ async function ensureOffscreen() {
 
 const SENSITIVE = new Set(['get_cookies', 'get_local_storage', 'execute_script', 'extract_token']);
 
-function logAction(port, method, params) {
+// MAALT 11/9 (Astra, efterproevet): her stod `params: JSON.stringify(params).slice(0, 200)`.
+// De foerste 200 tegn af ALLE parametre — ogsaa vaerdien til fill (adgangskoder), cookie-
+// vaerdier og adresser med login-tokens — laa i klartekst i chrome.storage.local. Popuppen
+// viser kun tid, vaerktoej og session, saa parametrene tjente intet. De gemmes ikke laengere,
+// og poster gemt af aeldre udgaver renses ved opdatering (rensHandlingslog i onInstalled).
+async function logAction(port, method) {
   const category = SENSITIVE.has(method) ? 'sensitive' : 'safe';
   const session = sessions.get(port);
   const entry = {
     time: Date.now(),
     method,
-    params: JSON.stringify(params).slice(0, 200),
     category,
     session: session?.label || `Port ${port}`,
     color: session?.color || 'grey',
   };
-  chrome.storage.local.get({ actionLog: [] }, ({ actionLog }) => {
-    actionLog.unshift(entry);
-    if (actionLog.length > 50) actionLog.length = 50;
-    chrome.storage.local.set({ actionLog });
-  });
+  try {
+    const { actionLog = [] } = await chrome.storage.local.get({ actionLog: [] });
+    // MAALT 11/9 af Astra (e2e-review): et logAction der koerte samtidig med rensHandlingslog i onInstalled, havde laest den
+    // gamle log foer oprydningen skrev - og skrev saa den gamle adgangskode tilbage. Hver skrivning renser derfor selv.
+    const renset = (Array.isArray(actionLog) ? actionLog : []).filter(Boolean).map(({ params, ...resten }) => resten);
+    renset.unshift(entry);
+    if (renset.length > 50) renset.length = 50;
+    await chrome.storage.local.set({ actionLog: renset });
+  } catch (e) {
+    console.warn('[BG] handlingslog kunne ikke skrives:', e?.message || e);
+  }
+}
+
+async function rensHandlingslog() {
+  try {
+    const { actionLog } = await chrome.storage.local.get({ actionLog: [] });
+    if (!Array.isArray(actionLog) || !actionLog.some((p) => p && 'params' in p)) return;
+    await chrome.storage.local.set({ actionLog: actionLog.map(({ params, ...resten }) => resten) });
+  } catch (e) {
+    console.warn('[BG] gammel handlingslog kunne ikke renses:', e?.message || e);
+  }
 }
 
 // ── Message Handler — receives commands from offscreen.js ──────────────────
@@ -1247,7 +1700,7 @@ function logAction(port, method, params) {
 chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
   if (msg.type === 'mcp_command') {
     const port = msg.port;
-    logAction(port, msg.method, msg.params);
+    logAction(port, msg.method);
     // 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()
@@ -1314,10 +1767,35 @@ chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
 
 const OAUTH_DOMAINS = ['accounts.google.com', 'login.microsoftonline.com', 'github.com/login/oauth', 'slack.com/oauth', 'app.hubspot.com/oauth'];
 
+// MAALT 10/9, reproduceret i selen: her stod kun `lastCreatedTabId = tab.id` — sat paa
+// HVER onCreated, ogsaa naar brugeren selv trykker Cmd+T eller aabner sin netbank.
+// `get_new_tab` adopterede den saa ind i agentens session, hvorefter skaermbillede,
+// sidetekst og localStorage af BRUGERENS fane var lovligt. Reproduktionen: bruger aabner
+// brugerens-netbank.example -> get_new_tab svarer med den -> fanen staar i tabIds.
+//
+// En ny fane hoerer til en session naar den er aabnet FRA en af dens faner (klik paa et
+// link med target=_blank, en OAuth-popup). Det staar i openerTabId. Er der ingen opener,
+// var det brugeren, og saa er den ikke vores.
 let lastCreatedTabId = null;
+// Aabneren huskes PR. FANE. En global "seneste aabner" blev 10/9 (Astra, reproduceret) laant af
+// den forkerte fane, naar to faner blev aabnet mens get_new_tab ventede paa tabs.get.
+const openerForFane = new Map();
+// MAALT 11/9 af Astra (R5 F9), reproduceret: fane 1 aabner en popup og lukkes derefter (typisk
+// "log ind i nyt vindue"). get_new_tab slog aabneren op i sessionens faner NU, hvor 1 var vaek,
+// og svarede not-ours paa sessionens egen popup. Ejeren huskes derfor i det oejeblik fanen
+// oprettes, hvor aabneren stadig staar i sin session.
+const ejerForFane = new Map();
 
 chrome.tabs.onCreated.addListener(async (tab) => {
   lastCreatedTabId = tab.id;
+  openerForFane.set(tab.id, tab.openerTabId ?? null);
+  if (openerForFane.size > 500) openerForFane.delete(openerForFane.keys().next().value);
+  let ejer = null;
+  if (tab.openerTabId != null) {
+    for (const [p, s] of sessions) { if (s.tabIds.has(tab.openerTabId)) { ejer = p; break; } }
+  }
+  ejerForFane.set(tab.id, ejer);
+  if (ejerForFane.size > 500) ejerForFane.delete(ejerForFane.keys().next().value);
 
   // Auto-claim OAuth popups for the session that opened them
   if (tab.pendingUrl || tab.url) {
@@ -1375,7 +1853,9 @@ function parsePlaceholderFormat(placeholder) {
   const order = parts.map(p => p.includes('Y') ? 'Y' : p.includes('M') ? 'M' : p.includes('D') ? 'D' : null);
   if (order.includes(null) || new Set(order).size !== 3) return null;
   const padded = parts.map(p => p.length >= 2);
-  return { sep, order, padded };
+  // Fjerde runde: YY og YYYY skal kunne skelnes, ellers skrives "2026" i et felt der kun tager to cifre.
+  const lengths = parts.map(p => p.length);
+  return { sep, order, padded, lengths };
 }
 
 function isoToFormat(iso, fmt) {
@@ -1383,7 +1863,7 @@ function isoToFormat(iso, fmt) {
   if (!m) throw new Error('Invalid ISO date: ' + iso);
   const [, y, mo, d] = m;
   return fmt.order.map((slot, i) => {
-    if (slot === 'Y') return y;
+    if (slot === 'Y') return fmt.lengths && fmt.lengths[i] === 2 ? y.slice(2) : y;
     if (slot === 'M') return fmt.padded[i] ? mo : String(parseInt(mo, 10));
     if (slot === 'D') return fmt.padded[i] ? d : String(parseInt(d, 10));
   }).join(fmt.sep);
@@ -1406,17 +1886,53 @@ function parseMonthYearText(text) {
   return null;
 }
 
-function valueLooksLikeIso(value, iso) {
-  if (!value || !iso) return false;
+function valueLooksLikeIso(raaVaerdi, iso, fmt) {
+  if (!raaVaerdi || !iso) return false;
   const [y, m, d] = iso.split('-');
-  const digits = value.replace(/\D/g, '');
-  if (digits.includes(y + m + d)) return true;
-  if (digits.includes(m + d + y)) return true;
-  if (digits.includes(d + m + y)) return true;
-  const hasYear = value.includes(y);
-  const hasMonth = value.includes(m) || value.includes(String(parseInt(m, 10)));
-  const hasDay = value.includes(d) || value.includes(String(parseInt(d, 10)));
-  return hasYear && hasMonth && hasDay;
+  const Y = Number(y), M = Number(m), D = Number(d);
+  // Fjerde runde: en aflaesning der BEGYNDER med den oenskede ISO-dato (fx "2026-01-02T12:00:00") er den dato,
+  // uanset hvilket format placeholderen lover - ellers blev en korrekt dato afvist og kalenderen proevet oveni.
+  if (raaVaerdi.trim().startsWith(iso) && !/\d/.test(raaVaerdi.trim().charAt(iso.length))) return true;
+  // MAALT 11/9 af Astra (R5): klokkeslaet og tidszone er ikke en del af datoen. F2: "02/01 20:26" gav timen 20
+  // som aaret 2020 og ok:true. F3: "02/01/2026 12:00 GMT" blev afvist af bogstavkontrollen paa "GMT", og
+  // kalenderen blev proevet oveni. Begge fjernes foer datoen laeses.
+  const value = raaVaerdi
+    .replace(/\b\d{1,2}:\d{2}(:\d{2}(\.\d+)?)?(\s*[ap]\.?m\.?)?(?![\d:])/gi, ' ')
+    .replace(/\b(GMT|UTC|UT|CET|CEST|EET|EEST|WET|WEST|BST|EST|EDT|CST|CDT|MST|MDT|PST|PDT)\b([+-]\d{1,2}(:?\d{2})?)?/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!value) return false;
+  // Astra, anden runde: tre `value.includes(...)` hver for sig godkendte "20/12/2026" som 2026-01-02.
+  // Tredje runde: tre `digits.includes(...)` koerte stadig FOER kontrollen af hele tal, saa
+  // "2026-1-1 02:00" blev 2026-11-02. Nu sammenlignes cifre som én streng KUN naar vaerdien udelukkende
+  // ER otte cifre - og med kendt format kun i formatets raekkefoelge ("01/12/2026" under DD/MM/YYYY er
+  // 1. december, ikke 12. januar).
+  const ordener = fmt?.order ? [fmt.order] : [['Y', 'M', 'D'], ['D', 'M', 'Y'], ['M', 'D', 'Y']];
+  const del = { Y: y, M: m, D: d };
+  if (/^\s*\d{8}\s*$/.test(value)) {
+    const cifre = value.trim();
+    return ordener.some((o) => o.map((slot) => del[slot]).join('') === cifre);
+  }
+  // Hele tal fra vaerdiens START - et klokkeslaet bagefter maa ikke levere dag eller maaned.
+  const tok = value.match(/\d+/g) || [];
+  const passer = (slot, s) => {
+    if (s === undefined) return false;
+    if (slot === 'Y') return (s.length === 4 && Number(s) === Y) || (s.length === 2 && Number(s) === Y % 100);
+    return s.length <= 2 && Number(s) === (slot === 'M' ? M : D);
+  };
+  // Fjerde runde: rene tal kun naar vaerdien ingen bogstaver har - i "2 Jan 26 05:00" blev timen ellers et aarstal.
+  if (!/\p{L}/u.test(value) && ordener.some((o) => o.every((slot, i) => passer(slot, tok[i])))) return true;
+  // Maanedsnavn ("2 Jan 2026", "2. maj 2026", "Jan 2, 2026"): dagen skal staa lige foer eller lige efter navnet.
+  const navne = [/jan/, /feb/, /mar/, /apr/, /ma[iyj]/, /jun/, /jul/, /aug/, /sep/, /o[ck]t/, /nov/, /de[cz]/];
+  const navn = navne[M - 1];
+  if (navn) {
+    const lav = value.toLowerCase();
+    const n = navn.source;
+    const foer = new RegExp('^\\s*(\\d{1,2})\\.?\\s+' + n + '[a-zæøå]*\\.?,?\\s+(\\d{4})(?!\\d)').exec(lav);
+    const efter = new RegExp('^\\s*' + n + '[a-zæøå]*\\.?\\s+(\\d{1,2}),?\\s+(\\d{4})(?!\\d)').exec(lav);
+    for (const r of [foer, efter]) if (r && Number(r[1]) === D && Number(r[2]) === Y) return true;
+  }
+  return false;
 }
 
 async function getDateInputInfo(tabId, selector) {
@@ -1485,25 +2001,9 @@ async function setDateMaskedTyping(tabId, selector, iso, format) {
   await debuggerFocus(tabId, selector);
   await debuggerAttach(tabId);
   try {
-    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);
     await cdpSend(tabId, 'Input.insertText', { text: formatted });
-    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-      type: 'keyDown', key: 'Tab', code: 'Tab',
-    });
-    await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-      type: 'keyUp', key: 'Tab', code: 'Tab',
-    });
+    await tastParAttached(tabId, { key: 'Tab', code: 'Tab' }, { key: 'Tab', code: 'Tab' });
   } finally {
     await debuggerDetach(tabId);
   }
@@ -1662,12 +2162,7 @@ async function setDatePicker(tabId, selector, iso) {
       await debuggerAttach(tabId);
       try {
         const key = delta > 0 ? 'PageDown' : 'PageUp';
-        await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-          type: 'keyDown', key, code: key,
-        });
-        await cdpSend(tabId, 'Input.dispatchKeyEvent', {
-          type: 'keyUp', key, code: key,
-        });
+        await tastParAttached(tabId, { key, code: key }, { key, code: key });
       } finally {
         await debuggerDetach(tabId);
       }
@@ -2010,6 +2505,26 @@ async function setCombobox(tabId, selector, values, opts = {}) {
   const waitIterations = Math.max(1, Math.ceil(waitMs / 100));
   const results = [];
 
+  // MAALT 9/9-2026: paa en aegte <select> brugte den her 8,5 sekunder paa at sige nej.
+  // Den klikkede feltet, forsoegte at tomme det med en input-vaerdisaetter (en <select>
+  // ER ikke et input), skrev tekst ind, og pollede saa 30 gange efter en listbox der
+  // aldrig kan opstaa — for saa at svare "no-options-rendered". Kapaciteten fandtes hele
+  // tiden i browser_select_option, som klarer samme felt paa 9 ms. Nu siger den det
+  // med det samme i stedet for at lade agenten vente og gaette.
+  const erNativeSelect = await debuggerEval(tabId, `(() => {
+    const el = document.querySelector(${JSON.stringify(selector)});
+    return el?.tagName === 'SELECT';
+  })()`).catch(() => false);
+  if (erNativeSelect) {
+    return {
+      ok: false,
+      error: 'native-select',
+      hint: 'Feltet er en almindelig <select>. Brug browser_select_option i stedet — ' +
+            'set_combobox er til dropdowns bygget af div/li med en listbox.',
+      selector,
+    };
+  }
+
   for (const val of valueList) {
     try {
       const inputEl = await resolveElement(tabId, selector);
@@ -2416,24 +2931,82 @@ async function dispatch(port, method, params) {
       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`);
       }
-      // Capture without stealing focus: CDP Page.captureScreenshot (default → fromSurface:false
-      // retry) works for background/visible tabs; captureVisibleTab is the secondary.
-      const tryCapture = async () => {
+      // MAALT 10/9, anden runde (Astra, reproduceret): reserveloesningen captureVisibleTab
+      // fotograferer den fane der er SYNLIG i vinduet, ikke agentens. Et tjek foer og et efter
+      // kunne ikke udelukke at brugeren skiftede A->B->A imens - og saa blev brugerens side
+      // leveret. To tidspunkter beviser ikke hvad der skete imellem. Reserveloesningen er derfor
+      // fjernet: CDP optager netop `tab.id`, eller der er intet billede.
+      // Samme runde: en frist paa optagelsen startede alligevel en ny runde (haev vinduet, optag
+      // igen), og kaeden kom over serverens 30 s. En frist markeres nu, og saa proeves der ikke igen.
+      // Sign-off 11/9 (Astra, R5 F8): hele kaeden har ét budget (skaermbilledeFrister). Fristen gaelder ogsaa mens
+      // cdpSend gentager et kald efter en afkobling - det var den gentagelse der bar kaeden over 30 s.
+      const { foersteMs, samletMs, haevMs = 0 } = skaermbilledeFrister();
+      const budgetSlut = Date.now() + samletMs;
+      // MAALT 11/9 af Astra (e2e runde 2), tre fejl i den haevede runde: reservationen blev trukket fra IGEN (reserven fik
+      // 0 ms), `debuggerAttach` laa uden for fristloebet (en gentilslutning paa 12,5 s bar kaeden over 30 s), og haevningen
+      // startede nye optagelser og smed de igangvaerende vaek - 1.29.0 fik netop svar fra dem der allerede loeb.
+      const igangvaerende = [];   // alle optagelser der stadig kan svare, paa tvaers af runder
+      const tryCapture = async ({ sidsteUdvej = false } = {}) => {
+        const reserveret = sidsteUdvej ? 0 : haevMs;   // kun foerste runde holder tid fri til haevningen
+        const denneRunde = [];
+        const optag = (p) => {
+          const kald = cdpSend(tab.id, 'Page.captureScreenshot', p);
+          kald.catch(() => {});   // et svar efter budgettet er ligegyldigt
+          igangvaerende.push(kald);
+          denneRunde.push(kald);
+          return kald;
+        };
+        const medFrist = async (loefte, ms) => {
+          let ur;
+          try {
+            return await Promise.race([
+              loefte,
+              new Promise((_, afvis) => {
+                const frist = Math.max(0, ms);
+                ur = setTimeout(() => afvis(new Error(`CDP svarede ikke inden ${frist} ms: Page.captureScreenshot`)), frist);
+              }),
+            ]);
+          } catch (e) {
+            if (e && typeof e === 'object' && /svarede ikke inden/.test(e.message || '')) e.ingenNyRunde = true;
+            throw e;
+          } finally {
+            clearTimeout(ur);
+          }
+        };
+        // Tilslutningen skal ogsaa ligge inde i budgettet: en gentilslutning kan tage lang tid paa et haevet vindue.
+        await medFrist(debuggerAttach(tab.id), budgetSlut - reserveret - Date.now());
+        const standard = optag({ format: 'png' });
         try {
-          await debuggerAttach(tab.id);
+          const shot = await medFrist(standard, Math.min(foersteMs, budgetSlut - reserveret - Date.now()));
+          return { image: 'data:image/png;base64,' + shot.data };
+        } catch (foersteFejl) {
+          // fromSurface:false proeves ogsaa efter en frist: i 1.29.0 var det netop fristen der naaede hertil, og den
+          // leverede billedet. Men efter en frist startes ingen runde mere, uanset hvordan reserven fejler.
+          // MAALT 11/9 af Astra (efterproevning af f084d1b): standardoptagelsen lykkedes efter 11 s, reserven fejlede, og
+          // fristen paa 10 s havde kasseret standardbilledet. Standardoptagelsen loeber derfor videre efter sin frist, og
+          // den af de to der lykkes foerst inden for budgettet, vinder.
+          optag({ format: 'png', fromSurface: false, captureBeyondViewport: false });
           try {
-            const shot = await cdpSend(tab.id, 'Page.captureScreenshot', { format: 'png' });
-            return { image: 'data:image/png;base64,' + shot.data };
-          } catch {
-            const shot = await cdpSend(tab.id, 'Page.captureScreenshot', {
-              format: 'png', fromSurface: false, captureBeyondViewport: false,
-            });
+            // Den haevede runde er sidste udvej paa en tildaekket skaerm og skal have tid tilbage (haevMs) - ellers naar
+            // 1.29.0's eneste virkende vej aldrig frem (Fable, e2e 11/9).
+            // MAALT 12/9 af Astra: alle igangvaerende optagelser laa i den SAMME Promise.any, saa et gammelt billede fra
+            // foer haevningen kunne svare foerst og vinde - selv om siden havde aendret sig imens. Rundens EGNE optagelser
+            // afgoer nu svaret; de aeldre taeller stadig med, men kun hvis rundens egne ikke naar frem.
+            let shot;
+            try {
+              shot = await medFrist(Promise.any(denneRunde), budgetSlut - reserveret - Date.now());
+            } catch (rundeFejl) {
+              const aeldre = igangvaerende.filter((k) => !denneRunde.includes(k));
+              if (!aeldre.length) throw rundeFejl;
+              // Et aeldre billede der ALLEREDE er kommet, svarer i samme oejeblik - ogsaa naar budgettet er brugt op.
+              shot = await medFrist(Promise.any(aeldre), budgetSlut - Date.now());
+            }
             return { image: 'data:image/png;base64,' + shot.data };
+          } catch (andenFejl) {
+            const fejl = andenFejl instanceof AggregateError ? andenFejl.errors[andenFejl.errors.length - 1] : andenFejl;
+            if (foersteFejl?.ingenNyRunde && fejl && typeof fejl === 'object') fejl.ingenNyRunde = true;
+            throw fejl;
           }
-        } catch {
-          // CDP failed entirely — native tabs API (needs the tab visible in its window).
-          const dataUrl = await chrome.tabs.captureVisibleTab(tab.windowId, { format: 'png' });
-          return { image: dataUrl };
         }
       };
 
@@ -2441,6 +3014,13 @@ async function dispatch(port, method, params) {
       try {
         return await tryCapture();
       } catch (firstErr) {
+        // 10/9 (Astra, R2) stod her: en frist betyder at kompositoren ikke svarede, saa en ny runde fordobler kun
+        // ventetiden. MAALT 11/9 af Fable: paa en TILDAEKKET skaerm haenger begge optagelser netop indtil vinduet haeves -
+        // 1.29.0 leverede dér et billede efter 16,7 s, hvor HEAD gav op. Budgettet (haevMs) holder kaeden under serverens
+        // 30 s, saa den sidste udvej maa proeves uanset om fejlen var en frist.
+        // Er budgettet brugt, er der ikke tid til en runde med haevet vindue foer serverens 30 s. (haevMs ovenfor er netop
+        // den tid der blev holdt fri til den her runde.)
+        if (budgetSlut - Date.now() <= 0) throw firstErr;
         // Both methods failed → the window is genuinely OCCLUDED (covered by other windows),
         // so Chrome's compositor produced no frames. LAST RESORT ONLY: raise the window to
         // de-occlude it, capture, then RESTORE the user's previously-focused window. This
@@ -2450,7 +3030,7 @@ async function dispatch(port, method, params) {
           await chrome.windows.update(tab.windowId, { focused: true, state: 'normal' });
           await chrome.tabs.update(tab.id, { active: true }).catch(() => {});
           await new Promise(r => setTimeout(r, 250)); // let it composite
-          return await tryCapture();
+          return await tryCapture({ sidsteUdvej: true });   // resten af budgettet - der er ikke en runde mere efter denne
         } catch (secondErr) {
           throw new Error(
             `Screenshot failed after focus-neutral AND raised attempts. ` +
@@ -2481,19 +3061,43 @@ async function dispatch(port, method, params) {
 
       const diag = { tried: [] };
 
+      // MAALT 10/9 af Astra (anden runde), reproduceret med en taeller: kode der udfoerte en
+      // effekt og SAA kastede, blev koert igen via debuggeren - to effekter. `sendt` beskyttede
+      // kun debugger-loekken. Er koden koert, er dens fejl svaret; den koeres ikke igen.
+      // Samme runde: scripting-stierne afventede ikke et Promise ("Promise.resolve(42)" gav {}).
+      // Den injicerede funktion er nu async og afventer resultatet.
+      const koertOgFejlede = (r) => ({
+        ok: false, error: r.message, name: r.name,
+        method: r.world === 'MAIN' ? 'scripting-main' : 'scripting-isolated',
+        note: 'Koden KOERTE og kastede en fejl. Den koeres ikke igen via debuggeren, fordi det den ' +
+              'naaede at goere foer fejlen saa ville ske to gange.',
+      });
+      // MAALT 11/9 af Astra (R5 F4), reproduceret: scriptet sendte en POST og returnerede et
+      // Promise; mens scripting-stien ventede, forsvandt dokumentet, og Chrome afviste med
+      // "Frame with ID 0 was removed." Handleren gik saa videre til debuggeren, som koerte koden
+      // igen - to POST'er. Forsvinder siden EFTER at koden er startet, kan den have koert, og
+      // den koeres ikke igen. Blev den aldrig indsproejtet, maa debuggeren stadig proeve.
+      const sidenForsvandt = (m) => /was removed|execution context was destroyed|document (was )?unloaded/i.test(m);
+      const maaskeKoert = (world, m) => ({
+        ok: false, error: m, maybe_ran: true,
+        method: world === 'MAIN' ? 'scripting-main' : 'scripting-isolated',
+        note: 'Siden skiftede eller lukkede mens koden koerte. Den kan allerede have koert, saa den ' +
+              'koeres ikke igen via debuggeren. Kald igen kun hvis det er sikkert at koere to gange.',
+      });
       // Step 1: try ISOLATED world
       try {
         const [result] = await chrome.scripting.executeScript({
           target: { tabId: tab.id },
           world: 'ISOLATED',
           args: [params.code],
-          func: (codeStr) => {
-            try {
-              const fn = new Function('return (' + codeStr + ')');
-              return { __ok: true, value: fn() };
-            } catch (e) {
-              return { __scriptingError: true, message: String(e?.message || e), name: e?.name, world: 'ISOLATED' };
-            }
+          func: async (codeStr) => {
+            // Oversaettelse og koersel er adskilt: fejler oversaettelsen (CSP, syntaks), koerte
+            // intet, og debuggeren maa proeve. Fejler KOERSLEN, er koden allerede koert.
+            let fn;
+            try { fn = new Function('return (' + codeStr + ')'); }
+            catch (e) { return { __kompilering: true, message: String(e?.message || e), name: e?.name, world: 'ISOLATED' }; }
+            try { return { __ok: true, value: await fn() }; }
+            catch (e) { return { __scriptingError: true, koerte: true, message: String(e?.message || e), name: e?.name, world: 'ISOLATED' }; }
           },
         });
         const r = result?.result;
@@ -2501,10 +3105,14 @@ async function dispatch(port, method, params) {
         if (r && typeof r === 'object' && r.__ok) {
           return { result: r.value, method: 'scripting-isolated' };
         }
-        if (r && typeof r === 'object' && r.__scriptingError) {
+        if (r && typeof r === 'object' && r.__scriptingError && r.koerte) return koertOgFejlede(r);
+        if (r && typeof r === 'object' && (r.__scriptingError || r.__kompilering)) {
           diag.isolated_error = r.message;
         }
       } catch (e) {
+        // Ingen maybe_ran her. MAALT 11/9 i Chrome for Testing 153: `new Function` i ISOLATED afvises af udvidelsens
+        // CSP ('unsafe-eval'), saa brugerens kode kan aldrig have koert i denne verden. Sign-off (Astra): en afvisning
+        // med "Frame with ID 0 was removed." foer start gav maybe_ran og nul koersler, hvor 1.29.0 koerte koden via MAIN.
         diag.isolated_throw = String(e?.message || e);
       }
 
@@ -2514,13 +3122,14 @@ async function dispatch(port, method, params) {
           target: { tabId: tab.id },
           world: 'MAIN',
           args: [params.code],
-          func: (codeStr) => {
-            try {
-              const fn = new Function('return (' + codeStr + ')');
-              return { __ok: true, value: fn() };
-            } catch (e) {
-              return { __scriptingError: true, message: String(e?.message || e), name: e?.name, world: 'MAIN' };
-            }
+          func: async (codeStr) => {
+            // Oversaettelse og koersel er adskilt: fejler oversaettelsen (CSP, syntaks), koerte
+            // intet, og debuggeren maa proeve. Fejler KOERSLEN, er koden allerede koert.
+            let fn;
+            try { fn = new Function('return (' + codeStr + ')'); }
+            catch (e) { return { __kompilering: true, message: String(e?.message || e), name: e?.name, world: 'MAIN' }; }
+            try { return { __ok: true, value: await fn() }; }
+            catch (e) { return { __scriptingError: true, koerte: true, message: String(e?.message || e), name: e?.name, world: 'MAIN' }; }
           },
         });
         const r = result?.result;
@@ -2528,11 +3137,14 @@ async function dispatch(port, method, params) {
         if (r && typeof r === 'object' && r.__ok) {
           return { result: r.value, method: 'scripting-main' };
         }
-        if (r && typeof r === 'object' && r.__scriptingError) {
+        if (r && typeof r === 'object' && r.__scriptingError && r.koerte) return koertOgFejlede(r);
+        if (r && typeof r === 'object' && (r.__scriptingError || r.__kompilering)) {
           diag.main_error = r.message;
         }
       } catch (e) {
-        diag.main_throw = String(e?.message || e);
+        const m = String(e?.message || e);
+        if (sidenForsvandt(m)) return maaskeKoert('MAIN', m);
+        diag.main_throw = m;
       }
 
       // Step 3: debugger fallback — the ONLY universal path for arbitrary STRING code
@@ -2544,10 +3156,15 @@ async function dispatch(port, method, params) {
       // fires and debuggerEval silently returned undefined → the caller saw a bare
       // `{method:"debugger"}` with no result. Also surface script exceptions + raw
       // diagnostics so a genuine failure is never mistaken for an empty success.
-      let rawDbg, dbgErr = '';
+      let rawDbg, dbgErr = '', sendt = false;
       for (let attempt = 0; attempt < 4; attempt++) {
         try {
           await debuggerAttach(tab.id);
+          // MAALT 10/9 af Astra: faldt debuggeren af EFTER at scriptet var sendt, loeb loekken
+          // videre og koerte BRUGERENS kode igen — op til fire gange. Vi kan ikke se om et
+          // vilkaarligt script muterer. Samme regel som for Runtime.evaluate i cdpSend: er det
+          // sendt, gentages det ikke automatisk. Kun en fejl FOER afsendelse proeves igen.
+          sendt = true;
           rawDbg = await cdpSend(tab.id, 'Runtime.evaluate', {
             expression: '(' + params.code + '\n)',
             returnByValue: true,
@@ -2563,12 +3180,14 @@ async function dispatch(port, method, params) {
             return { result: rawDbg.result.value, method: 'debugger' };
           }
           dbgErr = 'empty/undefined CDP response: ' + JSON.stringify(rawDbg);
+          break;   // tomt svar efter afsendelse: scriptet kan have koert — gentag ikke
         } catch (e) {
           const m = String(e?.message || e);
           if (m.startsWith('__SCRIPT_EX__')) {
             throw new Error(m.slice('__SCRIPT_EX__'.length) + ' | scripting-diag: ' + JSON.stringify(diag));
           }
           dbgErr = m;
+          if (sendt) break;   // sendt = maaske koert — se kommentaren ved afsendelsen
           if (!/detach|attach|empty|gone|given id|not attached/i.test(m)) break;
         }
         await debuggerDetach(tab.id).catch(() => {});
@@ -2576,6 +3195,8 @@ async function dispatch(port, method, params) {
       }
       throw new Error(
         'execute_script failed on all paths. debugger: ' + dbgErr +
+        (sendt ? ' | NB: scriptet blev sendt til siden foer det fejlede og KAN allerede have koert. ' +
+                 'Det gentages ikke automatisk — kald igen kun hvis det er sikkert at koere to gange.' : '') +
         ' | raw: ' + JSON.stringify(rawDbg) +
         ' | scripting-diag: ' + JSON.stringify(diag)
       );
@@ -2606,7 +3227,6 @@ async function dispatch(port, method, params) {
         // Primary path: debugger mouse events (isTrusted=true, works on React/Angular SPAs)
         const clickResult = await debuggerClick(tab.id, el.x, el.y);
         return {
-          ok: true,
           method: el.method || 'debugger',
           tag: el.tag,
           text: el.text,
@@ -2614,6 +3234,15 @@ async function dispatch(port, method, params) {
           // 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 || {}),
+          // MAALT 9/9 (issue #19, fjerde gang samme fejlklasse efter select_option og fill):
+          // `ok: true` stod hardkodet, og `landed` blev spredt ind bagefter. Klikket svarede
+          // altsaa ja og nej i samme aandedrag, og en agent laeser `ok`.
+          // Et element der forsvandt ER en virkning — derfor tæller `detached` som landet.
+          // MAALT 12/9 af Astra (N1): `ok` stod FOER settle-vaerdien her og i click_xy, hvor select_option var immun -
+          // saa et svar fra siden kunne bestemme vaerktoejets egen dom. Ikke naabart i dag, men det er samme klasse som
+          // lige blev lukket for noten, og de tre steder var indbyrdes uens. Vaerktoejets vurdering staar nu sidst.
+          ok: klikLandede(clickResult),
+          ...(uvisVurdering(clickResult) || {}),
         };
       } catch (e) {
         // Fallback: synthetic click via chrome.scripting for anti-automation sites
@@ -2633,9 +3262,46 @@ async function dispatch(port, method, params) {
         //
         // 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 || '')) {
+        // MAALT 10/9 af Astra (anden runde), reproduceret: museknappen var sendt ned og op, CDP meldte
+        // derefter afkobling - og reserveloesningen klikkede EN GANG TIL. To effekter, ok:true. Er
+        // trykket sendt, kan klikket vaere landet; saa klikkes der ikke igen.
+        if (e?.trykSendt) {
+          return {
+            ok: false, error: e.message, maaske_landet: true, method: 'debugger',
+            note: 'Museklikket blev sendt, men debuggeren koblede fra bagefter. Klikket KAN vaere landet, ' +
+                  'saa det gentages ikke. Tjek siden foer du klikker igen.',
+          };
+        }
+        // MAALT 11/9 i Chrome for Testing: en fane i baggrunden faar ikke Input.* - musebevaegelsen udloeber FOER
+        // trykket er sendt. Intet klik kan vaere landet (trykSendt er falsk, se ovenfor), saa script-klikket er sikkert.
+        const inputFristFoerTryk = /svarede ikke inden \d+ ms: Input\./.test(e?.message || '');
+        if (inputFristFoerTryk || /Debugger detached|Debugger attach failed|not attached/i.test(e?.message || '')) {
+          // Ingen "ny adresse = klikket navigerede"-regel her. Astra (efterproevning af c1496d4): en UAFHAENGIG navigation
+          // fjernede rammen foer scriptet koerte, og reglen svarede ok:true med nul handlinger. En afvisning beviser ikke at
+          // scriptet koerte, og en ny adresse beviser ikke at det var klikket.
           const r = await scriptingClick(tab.id, params.selector);
-          if (r.ok) return { ok: true, method: 'scripting-fallback', tag: r.tag };
+          if (r.ok && !inputFristFoerTryk) {
+            // Debuggeren var blokeret eller afkoblet: samme svar som 1.29.0. landed vedlaegges kun naar klikket er bevist - Astra
+            // (efterproevning af c826f63): en menu der aabnede paa mousedown, blev ellers meldt som landed:false.
+            return { ok: true, method: 'scripting-fallback', tag: r.tag, ...(klikLandede(r) ? { landed: true } : {}) };
+          }
+          if (r.ok) {
+            // Sign-off 11/9 (Astra og Fable): paa en baggrundsfane svarede reserven ok:true, ogsaa naar siden intet gjorde
+            // (handler der kraever isTrusted). 1.29.0 svarede med en fejl. Nu kraever ok samme bevis som de andre klikveje.
+            // Viste siden ingen reaktion, er klikket alligevel sendt - saa det meldes som "kan vaere landet", ikke gentag blindt.
+            if (klikLandede(r)) {
+              return {
+                ok: true, method: 'scripting-fallback', tag: r.tag, landed: true,
+                note: 'Fanen var i baggrunden, saa musehaendelser naaede ikke frem. Klikket blev udfoert med et script i stedet.',
+              };
+            }
+            return {
+              ok: false, method: 'scripting-fallback', tag: r.tag, landed: false, maaske_landet: true, error: e.message,
+              note: 'Fanen var i baggrunden, saa musehaendelser naaede ikke frem. Et script-klik blev sendt, men klikket selv ' +
+                    'gav ingen synlig virkning: enten kraever siden et aegte klik, eller klikket virkede uden synlig aendring. Tjek siden, ' +
+                    'og kald browser_switch_tab og klik igen kun hvis intet skete.',
+            };
+          }
         }
         throw e;
       }
@@ -2661,6 +3327,27 @@ async function dispatch(port, method, params) {
         await debuggerFill(tab.id, parsed.selector, params.value);
         return { ok: true, method: 'debugger' };
       } catch (e) {
+        // MAALT 10/9 af Astra: debugger-vejen timede ud, og reserveloesningen skrev saa hele
+        // vaerdien med den native setter. Men Promise.race afbryder ikke — tastetrykkene fra
+        // debugger-forsoeget kan lande BAGEFTER. Reproduceret: "X" blev til "XX", og kaldet
+        // svarede ok:true. To regler: er vaerdien der allerede efter en frist, er vi faerdige;
+        // og efter reserveloesningen laeses feltet igen, saa en fordobling ses i stedet for
+        // at blive meldt som succes.
+        const laesFelt = async () => {
+          const r = await safeExecuteScript(tab.id, (sel) => {
+            const el = document.querySelector(sel);
+            return el && 'value' in el ? el.value : null;
+          }, [parsed.selector]).catch(() => null);
+          return r && !r.cspBlocked ? r.result : null;
+        };
+        const fristUdloeb = /svarede ikke inden/.test(e?.message || '');
+        if (fristUdloeb) await new Promise((r) => setTimeout(r, 400));
+        // MAALT 11/9 af Astra (R5 F1): feltet laeses FOER reserveloesningen skriver. Det er det der skiller en
+        // side der afviste vaerdien (feltet stod stille) fra en side der formaterede den (feltet aendrede sig).
+        const foer = await laesFelt();
+        if (fristUdloeb && foer === params.value) {
+          return { ok: true, method: 'debugger', note: 'landede trods fristen' };
+        }
         // Fallback to executeScript if debugger fails
         const scriptResult = await safeExecuteScript(tab.id, (sel, val) => {
           const el = document.querySelector(sel);
@@ -2675,8 +3362,59 @@ async function dispatch(port, method, params) {
           el.dispatchEvent(new Event('change', { bubbles: true }));
           return { ok: true };
         }, [parsed.selector, params.value]);
-        if (!scriptResult.cspBlocked) return scriptResult.result;
-        return { ok: false, error: e.message, method: 'debugger' };
+        if (scriptResult.cspBlocked) return { ok: false, error: e.message, method: 'debugger' };
+        if (!scriptResult.result?.ok) return scriptResult.result;
+        await new Promise((r) => setTimeout(r, 300));
+        const endelig = await laesFelt();
+        // Kun to sluttilstande er fejl. FORDOBLET: et forsinket Input.insertText landede efter
+        // setteren ("X" -> "XX", reproduceret). TOEMT: et forsinket Cmd+A/Backspace ryddede feltet
+        // igen. Alt andet — "5" der bliver til "5,00 kr", et telefonnummer med mellemrum — er
+        // feltets egen formatering og maa ikke meldes som fejl.
+        const v = String(params.value ?? '');
+        if (typeof endelig === 'string' && endelig !== v) {
+          const fordoblet = endelig === v + v || (v.length >= 3 && endelig.includes(v + v));
+          if (fordoblet || (v && endelig === '')) {
+            return {
+              ok: false, method: 'fallback', error: fordoblet ? 'feltet-fordoblet' : 'feltet-toemt',
+              forventet: v, faktisk: endelig,
+              note: 'Et forsinket tastetryk fra debugger-forsoeget landede efter reserveloesningen.',
+            };
+          }
+          // Anden runde: "OLD" efter fill("NEW") blev kaldt formatering. Tredje og fjerde runde: hver regel for
+          // "det er bare formatering" havde huller ("5" -> "15", "1.5" -> "15", Unicode-minus, "+45" -> "+1 45").
+          // Femte runde (R5 F1): at melde ENHVER afvigelse som fejl gjorde korrekt formatering ("1.234,50 kr",
+          // "+45 12 34 56 78") til ok:false, hvor 1.29.0 sagde ok. Skellet maales nu i stedet for at gaettes:
+          //   stod feltet stille (foer === efter)  -> uvist, og det siges: afviger + uaendret (se nedenfor)
+          //   aendrede det sig til noget andet     -> ok:true, men afviger:true med den faktiske vaerdi
+          // Kalderen faar altsaa aldrig en tavs succes paa en anden vaerdi end den der blev skrevet.
+          // Sign-off 11/9 (Astra og Fable, begge reproduceret): feltet viste allerede "1.234,50 kr", fill("1234.5")
+          // blev formateret tilbage til praecis det samme, og svaret var "siden tog ikke imod vaerdien" (1.29.0: ok).
+          // Foer = efter kan ikke skelne en afvisning fra en vaerdi der allerede stod der i sidens format.
+          // Kun en toemning der ikke skete er entydig: intet format goer "" til noget andet.
+          if (typeof foer === 'string' && endelig === foer) {
+            if (!v) {
+              return {
+                ok: false, method: 'fallback', error: 'feltet-viser-andet', forventet: v, faktisk: endelig,
+                note: 'Feltet skulle toemmes, men viser det samme som foer.',
+              };
+            }
+            return {
+              ok: true, method: 'fallback', value: endelig, afviger: true, uaendret: true, forventet: v, faktisk: endelig,
+              note: 'Feltet viste det samme foer og efter skrivningen. Enten stod vaerdien der allerede i sidens eget ' +
+                    'format, eller siden tog ikke imod den. Tjek `faktisk` foer du gaar videre.',
+            };
+          }
+          return {
+            ok: true, method: 'fallback', value: endelig, afviger: true, forventet: v, faktisk: endelig,
+            ...(typeof foer === 'string' ? {} : { foer_ukendt: true }),
+            note: 'Feltet aendrede sig, men viser en anden tekst end den der blev skrevet - fx formatering ' +
+                  '("5,00 kr", "+45 12 34 56 78") eller en afkortning. Tjek `faktisk`, hvis den praecise vaerdi betyder noget.',
+          };
+        }
+        return {
+          ok: true, method: 'fallback', value: endelig ?? v,
+          ...(typeof endelig === 'string' ? {} : { verificeret: false }),
+        };
       }
     }
 
@@ -2711,9 +3449,16 @@ async function dispatch(port, method, params) {
             await new Promise(r => setTimeout(r, 250));
             const v = await readBackValue(tab.id, params.selector);
             tried.push({ path: 'masked', format: fmt.order.join(fmt.sep), value: v });
-            if (valueLooksLikeIso(v, iso)) return { ok: true, method: 'masked', value: v, format: fmt.order.join(fmt.sep) };
+            if (valueLooksLikeIso(v, iso, fmt)) return { ok: true, method: 'masked', value: v, format: fmt.order.join(fmt.sep) };
           } catch (e) {
-            tried.push({ path: 'masked', error: e.message });
+            // MAALT 10/9 af Astra: en frist her betyder ikke at intet skete. Tastetrykkene kan
+            // allerede staa i feltet, og saa ville kalender-vejen nedenfor saette datoen EN GANG
+            // TIL. Laes feltet foer vi proever noget andet.
+            const v = await readBackValue(tab.id, params.selector).catch(() => null);
+            tried.push({ path: 'masked', error: e.message, value: v });
+            if (valueLooksLikeIso(v, iso, fmt)) {
+              return { ok: true, method: 'masked', value: v, format: fmt.order.join(fmt.sep), note: 'landede trods fejl i afsendelsen' };
+            }
           }
         } else {
           tried.push({
@@ -2734,11 +3479,13 @@ async function dispatch(port, method, params) {
 
       // Path C: calendar-picker navigation
       if (!params.skip_picker) {
+        // Fjerde runde (Astra): kalender-grenen glemte feltets format, saa 01/12/2026 blev godkendt som 12. januar.
+        const kendtFormat = parsePlaceholderFormat(info.placeholder) || parsePlaceholderFormat(info.ariaLabel);
         const r = await setDatePicker(tab.id, params.selector, iso);
         await new Promise(r2 => setTimeout(r2, 200));
         const v = await readBackValue(tab.id, params.selector);
         tried.push({ path: 'picker', ...r, value: v });
-        if (r.ok && valueLooksLikeIso(v, iso)) return { ok: true, method: 'picker', value: v, navAttempts: r.navAttempts };
+        if (r.ok && valueLooksLikeIso(v, iso, kendtFormat)) return { ok: true, method: 'picker', value: v, navAttempts: r.navAttempts };
       }
 
       const visibleErrors = await collectVisibleErrors(tab.id, params.selector);
@@ -2835,26 +3582,44 @@ async function dispatch(port, method, params) {
       const vkCode = VK_CODES[key];
       const vkParams = vkCode ? { windowsVirtualKeyCode: vkCode, nativeVirtualKeyCode: vkCode } : {};
 
+      // MAALT 10/9 af Astra: keyDown og keyUp stod i samme try. Timede keyDown ud — og det
+      // kan det, selv naar tasten LANDEDE (Enter der sender en formular) — blev keyUp aldrig
+      // sendt. En tast der kun er trykket ned, er en tast der haenger. Nu sendes keyUp altid,
+      // og svaret siger om nedtrykket fejlede i stedet for at kaste raat.
       await debuggerAttach(tab.id);
+      let tastFejl = null;
       try {
-        await cdpSend(tab.id, 'Input.dispatchKeyEvent', {
-          type: 'keyDown',
-          key,
-          code: params.code || key,
-          modifiers,
-          text: key.length === 1 ? key : '',
-          ...vkParams,
-        });
-        await cdpSend(tab.id, 'Input.dispatchKeyEvent', {
-          type: 'keyUp',
-          key,
-          code: params.code || key,
-          modifiers,
-          ...vkParams,
-        });
+        try {
+          await cdpSend(tab.id, 'Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key,
+            code: params.code || key,
+            modifiers,
+            text: key.length === 1 ? key : '',
+            ...vkParams,
+          });
+        } catch (e) { tastFejl = e; }
+        try {
+          await cdpSend(tab.id, 'Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key,
+            code: params.code || key,
+            modifiers,
+            ...vkParams,
+          });
+        } catch (e) { if (!tastFejl) tastFejl = e; }
       } finally {
         await debuggerDetach(tab.id);
       }
+      if (tastFejl) {
+        const frist = /svarede ikke inden/.test(tastFejl.message || '');
+        return {
+          ok: false, key, error: tastFejl.message,
+          ...(frist ? { maaske_landet: true,
+            note: 'Chrome kvitterede ikke inden fristen. Tasten kan alligevel have virket ' +
+                  '(fx en formular der blev sendt) — tjek siden foer du trykker igen.' } : {}),
+        };
+      }
       return { ok: true, key };
     }
 
@@ -2873,6 +3638,14 @@ async function dispatch(port, method, params) {
       // FB/Twitter/IG only trigger lazy-load on continuous wheel events, not a single large delta.
       const dx = params.x || 0;
       const dy = params.y || 0;
+      // Hvor stod siden FOER vi roerte den? Uden det tal kan reserveloesningen ikke vide
+      // hvor meget hjulet naaede, og ender med at rulle for langt.
+      // MAALT 10/9: her stod `.catch(() => ({x:0,y:0}))`. Et opdigtet nulpunkt er vaerre end
+      // ingen: stod siden paa 500 og laesningen fejlede, ville reserveloesningen rulle OP.
+      const start = await debuggerEval(tab.id, '({x: window.scrollX, y: window.scrollY})')
+        .catch(() => null);
+      const startKendt = !!start && typeof start.y === 'number';
+      const startX = startKendt ? start.x : 0, startY = startKendt ? start.y : 0;
       try {
         await debuggerAttach(tab.id);
         const STEP_SIZE = 300; // pixels per wheel-event (matches a typical mouse-wheel notch)
@@ -2890,9 +3663,70 @@ async function dispatch(port, method, params) {
         // before any subsequent commands run (caller often scrapes immediately after)
         await new Promise(r => setTimeout(r, 600));
       } catch (e) {
-        // Fallback to window.scrollBy for simple pages (synthetic but works on non-anti-scrape sites)
-        await debuggerEval(tab.id, `window.scrollBy(${dx}, ${dy})`);
-        return { ok: true, scrolled: { x: dx, y: dy }, method: 'fallback', fallback_reason: e.message };
+        // MAALT 9/9 af reviewet: her stod `window.scrollBy(dx, dy)` — altsaa "rul det HELE igen".
+        // Promise.race afbryder ikke det kald den opgiver, saa hjultrin der allerede virkede
+        // bliver liggende. Reproduceret: scroll({y:600}), foerste trin flyttede 300 uden at
+        // kvittere, fallbacken lagde 600 oveni = 900 faktisk, 600 rapporteret.
+        // scrollTo mod en beregnet MAAL-position er idempotent: har hjulet allerede rullet
+        // halvdelen, ruller vi kun resten.
+        // MAALT 10/9 af Astra, i MIN egen rettelse fra fire timer foer: her stod
+        // `.catch(() => null)` og derefter `ok: true` ubetinget. Fejlede ogsaa
+        // reserveloesningen, svarede vaerktoejet succes med nul rullede pixels.
+        // Femte gang samme fejlklasse paa én dag — og den her var min.
+        // MAALT 10/9 af Astra (anden runde), reproduceret: kunne starten ikke laeses, blev der
+        // rullet RELATIVT - og hjultrin der allerede var landet blev lagt oveni (500 -> 1400 ved
+        // y:600). Flaget start_ukendt dokumenterede risikoen uden at forhindre den. Uden kendt
+        // start findes ingen rulning der kan gentages uden at rulle dobbelt, saa der rulles ikke.
+        if (!startKendt) {
+          return {
+            ok: false, method: 'fallback', error: 'scroll-uvist', start_ukendt: true, hjul_fejl: e.message,
+            hint: 'Hjul-kaldet svarede ikke, og startpositionen kunne ikke laeses, saa siden KAN have ' +
+                  'rullet. Laes window.scrollY med browser_execute_script, og rul derefter det der mangler.',
+          };
+        }
+        const landede = await debuggerEval(tab.id, `(() => {
+          const foer = { x: window.scrollX, y: window.scrollY };
+          window.scrollTo(${startX} + ${dx}, ${startY} + ${dy});
+          return { foer, efter: { x: window.scrollX, y: window.scrollY } };
+        })()`).catch((fejl) => ({ fejl: fejl?.message || String(fejl) }));
+
+        if (!landede || landede.fejl) {
+          return {
+            ok: false, method: 'fallback', error: 'scroll-mislykkedes',
+            hjul_fejl: e.message,
+            fallback_fejl: landede?.fejl || 'reserveloesningen svarede ikke',
+          };
+        }
+        // MAALT 11/9 af Astra (e2e-review): med blød rulning (scroll-behavior: smooth) naar siden foerst maalet over de naeste
+        // billeder. Laest i samme oejeblik blev en rulning der lykkedes meldt som "bunden er maaske naaet" (1.29.0: ok).
+        // Positionen laeses igen hvert 100 ms, til maalet er naaet eller siden staar stille - hoejst ca. 1 s.
+        // Astra (efterproevning af c826f63): bundet af et ANTAL forsoeg kom en side med langsomme opslag over serverens 30 s
+        // (1.29.0: svar efter 3 s). Genlaesningen er bundet af tid.
+        const roSlut = Date.now() + 1000;
+        while (Date.now() < roSlut && !(landede.efter.x === startX + dx && landede.efter.y === startY + dy)) {
+          await new Promise((r) => setTimeout(r, 100));
+          const nu = await debuggerEval(tab.id, '({x: window.scrollX, y: window.scrollY})').catch(() => null);
+          if (!nu || typeof nu.y !== 'number') break;
+          const stille = nu.x === landede.efter.x && nu.y === landede.efter.y;
+          landede.efter = nu;
+          if (stille) break;
+        }
+        const flyttede = landede.efter.x !== landede.foer.x || landede.efter.y !== landede.foer.y;
+        const alleredeFremme = !flyttede && startKendt &&
+          landede.efter.x === startX + dx && landede.efter.y === startY + dy;
+        // Astra (efterproevning af cf5b98a): en animation der gik frem, tilbage og foerst naaede maalet efter 1,6 s, fik
+        // svaret ok:false "siden flyttede sig ikke" (1.29.0: ok:true). En rulning der ER sendt, meldes aldrig som fiasko.
+        // Kan bevaegelsen ikke ses inden for ventetiden, er svaret uvist - samme aerlighed som maaske_landet paa klik.
+        return {
+          ok: true,
+          method: 'fallback', fallback_reason: e.message,
+          position: landede.efter, foer: landede.foer,
+          ...(flyttede || alleredeFremme ? {} : {
+            uvist: true,
+            note: 'Rulningen blev sendt, men positionen var uaendret da vi svarede: enten er en blød rulning stadig i gang, ' +
+                  'eller bunden er naaet. Laes window.scrollY med browser_execute_script hvis den praecise position betyder noget.',
+          }),
+        };
       }
       return { ok: true, scrolled: { x: dx, y: dy }, method: 'mouseWheel-stepped' };
     }
@@ -2943,8 +3777,30 @@ async function dispatch(port, method, params) {
       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 } };
+      // MAALT 10/9: debuggerClick maaler om klikket landede, men svaret blev smidt vaek og
+      // `ok: true` stod hardkodet — samme fejl som `click` havde (issue #19). Samme regel her.
+      let klik;
+      try {
+        klik = await debuggerClick(tab.id, params.x, params.y);
+      } catch (e) {
+        // Samme regel som click (Astra, tredje runde): er museknappen sendt, kan klikket vaere landet -
+        // og en kastet fejl mister markeringen over forbindelsen.
+        if (e?.trykSendt) {
+          return {
+            ok: false, error: e.message, maaske_landet: true, clicked_at: { x: params.x, y: params.y },
+            note: 'Museklikket blev sendt, men debuggeren fejlede bagefter. Klikket KAN vaere landet, ' +
+                  'saa det gentages ikke. Tjek siden foer du klikker igen.',
+          };
+        }
+        throw e;
+      }
+      return {
+        clicked_at: { x: params.x, y: params.y },
+        ...(klik || {}),
+        // Samme som click: vaerktoejets egen dom og et uvist klik staar sidst, saa siden ikke kan overskrive dem.
+        ok: klikLandede(klik),
+        ...(uvisVurdering(klik) || {}),
+      };
     }
 
     case 'reattach_debugger': {
@@ -2999,6 +3855,20 @@ async function dispatch(port, method, params) {
         // 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.
+        // MAALT 8/9 paa forbrugeragenten.dk/penge-tilbage: her laa en anden fejl af samme
+        // familie. Vagten laeste `sel.value` SYNKRONT lige efter dispatch og kaldte enhver
+        // afvigelse "rullet tilbage". Men et React-styret felt der ARBEJDER ser praecis
+        // saadan ud: onChange koerer, komponenten gemmer valget et andet sted og nulstiller
+        // sin egen `value`. Vi maalte altsaa succes som fiasko — og sagde ok:false om et
+        // valg der faktisk landede (chippen "Norlys Energi ×" stod paa siden bagefter).
+        //
+        // Det er den omvendte udgave af issue #19, og rettelsen er den samme som issuet
+        // beder om: maal EFFEKTEN, ikke feltet. Aendrede resten af siden sig, gjorde
+        // komponenten sit arbejde — uanset hvad feltet staar paa nu.
+        const aftryk = `(function(el){
+          return el.options.length + '|' + (el.form ? el.form.innerText.length : document.body.innerText.length);
+        })(document.querySelector(${JSON.stringify(params.selector)}))`;
+
         const valg = await debuggerEval(tab.id, `
           (function() {
             const sel = document.querySelector(${JSON.stringify(params.selector)});
@@ -3011,20 +3881,44 @@ async function dispatch(port, method, params) {
               return JSON.stringify({ found: false, error: 'Ingen mulighed matchede: ' + oensket,
                 available: Array.from(sel.options).map(o => o.text.trim()).slice(0, 25) });
             }
+            const foer = ${aftryk};
             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 JSON.stringify({ found: true, wanted: opt.value, actual: sel.value, text: opt.text.trim(), foer });
           })()
         `);
         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}"` };
+
+        if (r.actual === r.wanted) return { ok: true, type: 'native_select', selected: r.text, value: r.actual };
+
+        // Feltet holder ikke vaerdien. Giv rammen tid til at gen-rendere, og se saa efter
+        // om NOGET andet aendrede sig. Gjorde det det, blev valget taget imod.
+        await new Promise((res) => setTimeout(res, 150));
+        const efter = await debuggerEval(tab.id, `
+          (function() {
+            const sel = document.querySelector(${JSON.stringify(params.selector)});
+            if (!sel) return JSON.stringify({ vaerdi: null, aftryk: null });
+            return JSON.stringify({ vaerdi: sel.value, aftryk: ${aftryk} });
+          })()
+        `);
+        let e; try { e = JSON.parse(efter); } catch { e = null; }
+
+        if (e && e.vaerdi === r.wanted) {
+          return { ok: true, type: 'native_select', selected: r.text, value: e.vaerdi };
+        }
+        if (e && e.aftryk && r.foer && e.aftryk !== r.foer) {
+          return {
+            ok: true, type: 'native_select', selected: r.text, value: e.vaerdi,
+            note: `Feltet nulstillede sig selv til "${e.vaerdi}", men siden reagerede — ` +
+                  'et styret felt der gemmer valget et andet sted. Valget landede.',
+          };
         }
-        return { ok: true, type: 'native_select', selected: r.text, value: r.actual };
+        return { ok: false, type: 'native_select',
+          error: `Valget blev rullet tilbage: satte "${r.wanted}", feltet staar paa "${e ? e.vaerdi : r.actual}", ` +
+                 'og intet andet paa siden aendrede sig.' };
       }
 
       // Custom dropdown (Angular Material, React Select, etc.)
@@ -3052,12 +3946,15 @@ async function dispatch(port, method, params) {
       // ordret "it never reports success without the field actually changing".
       return {
         ...(valgKlik || {}),
-        ok: valgKlik?.landed !== false,
+        ok: klikLandede(valgKlik),
         type: 'custom_dropdown',
         selected: oensket,
-        ...(valgKlik?.landed === false
-          ? { error: 'Klikket paa muligheden blev ikke taget imod af siden: ' + oensket }
-          : {}),
+        // MAALT 12/9 af Astra: her stod fejlteksten paa ALT der ikke var bevist landet - ogsaa naar koden lige havde
+        // regnet ud at den IKKE ved det. En skarp benaegtelse oven paa en uvished er mindre aerlig end ingen tekst.
+        ...(uvisVurdering(valgKlik)
+          || (!klikLandede(valgKlik)
+            ? { error: 'Klikket paa muligheden blev ikke taget imod af siden: ' + oensket }
+            : {})),
       };
     }
 
@@ -3113,6 +4010,8 @@ async function dispatch(port, method, params) {
       if (tab.url.startsWith('chrome://')) throw new Error('Cannot interact with chrome:// pages');
       const urlPattern = params.url_pattern || '';
       const timeout = params.timeout || 15000;
+      const netFrister = netvaerkFrister();
+      const budgetSlut = Date.now() + netFrister.budgetMs;
 
       await debuggerAttach(tab.id);
       try {
@@ -3134,10 +4033,18 @@ async function dispatch(port, method, params) {
               if (!urlPattern || url.includes(urlPattern)) {
                 chrome.debugger.onEvent.removeListener(listener);
                 clearTimeout(timer);
-                // Try to get response body
-                cdpSend(tab.id, 'Network.getResponseBody', {
-                  requestId: eventParams.requestId,
-                }).then(bodyResult => {
+                // Try to get response body - kun inden for vaerktoejets budget (netvaerkBudgetMs). Naar den ikke frem, er
+                // svaret body:null som i 1.29.0, i stedet for at serverens 30 s loeber ud.
+                const bodyKald = cdpSend(tab.id, 'Network.getResponseBody', { requestId: eventParams.requestId });
+                bodyKald.catch(() => {});
+                let bodyUr;
+                Promise.race([
+                  bodyKald,
+                  new Promise((ok) => {
+                    const bodyFrist = Math.min(netFrister.bodyMaxMs, Math.max(netFrister.bodyMinMs, budgetSlut - Date.now()));
+                    bodyUr = setTimeout(() => ok(null), bodyFrist);
+                  }),
+                ]).finally(() => clearTimeout(bodyUr)).then(bodyResult => {
                   resolve({
                     ok: true,
                     url,
@@ -3201,8 +4108,101 @@ async function dispatch(port, method, params) {
     }
 
     case 'get_cookies': {
-      const cookies = await chrome.cookies.getAll({ domain: params.domain });
-      return { cookies: cookies.map(c => ({ name: c.name, value: c.value, domain: c.domain, path: c.path })) };
+      // MAALT 10/9, reproduceret i selen: uden `domain` blev filteret {} — altsaa INTET
+      // filter, altsaa hver eneste cookie i profilen, inklusive httpOnly-sessionscookies
+      // som sidens eget JS ikke maa se. Skemaet siger required: ['domain'], men serveren
+      // videresender argumenter uvalideret, saa skemaet var en henstilling.
+      if (!params.domain || typeof params.domain !== 'string' || !params.domain.trim()) {
+        return {
+          ok: false,
+          error: 'domain-mangler',
+          hint: 'Angiv `domain`. Uden det ville kaldet returnere HVER cookie i profilen — ' +
+                'ogsaa fra sider der intet har med opgaven at goere.',
+        };
+      }
+      // MAALT 10/9, to runder. Foerste udgave gaettede domaeneslaegtskab ud fra fanernes
+      // vaertsnavne ("a.example.com ligger under com"). Astra omgik det tre veje: en fane paa
+      // https://com/ aabnede hele .com, en file://bank.example/-fane gav bankens cookies uden at
+      // nogen side var aabnet, og et tomt vaertsnavn (about:blank) lod "bank.example." slippe
+      // igennem. Et domaene kan man ikke raesonnere sig til uden public suffix-listen. Saa nu
+      // spoerges Chrome i stedet: hvilke cookies ville du SENDE til de http(s)-sider sessionen har
+      // aabne? Kun dem - og kun dem der passer paa det domaene der blev bedt om.
+      const session = getSession(port);
+      // Astra, tredje runde: en inkognito-fane har sit EGET cookie-lager. Uden storeId blev den
+      // almindelige profils cookies laest for en inkognito-fane.
+      let lagre = null;
+      try { lagre = await chrome.cookies.getAllCookieStores(); } catch {}
+      const lagerFor = (tabId) => (lagre || []).find((l) => (l.tabIds || []).includes(tabId))?.id;
+      const sider = [];
+      let ukendtLager = false;
+      for (const id of session.tabIds) {
+        const t = await chrome.tabs.get(id).catch(() => null);
+        try {
+          const u = new URL(t?.url || '');
+          if ((u.protocol === 'https:' || u.protocol === 'http:') && u.hostname) {
+            const storeId = lagerFor(id);
+            // Astra (sign-off 11/9): fejlede getAllCookieStores for en inkognitofane, blev storeId udeladt, og Chrome
+            // laeste den almindelige profils lager. Kan en inkognitofanes lager ikke findes, laeses intet for den.
+            if (t.incognito && !storeId) { ukendtLager = true; continue; }
+            // Fanens vaertsnavn er altid ASCII (punycode). Et afsluttende punktum er en ANDEN cookie-vaert i
+            // Chromium (Astra, fjerde runde: x.example. fik cookies fra x.example) - saa det bevares.
+            sider.push({ u, vaert: u.hostname.toLowerCase(), storeId });
+          }
+        } catch {}
+      }
+      if (!sider.length && ukendtLager) {
+        return {
+          ok: false, error: 'cookie-lager-ukendt',
+          hint: 'Fanen er et inkognitovindue, og Chrome oplyste ikke dens cookie-lager. Intet blev laest - ellers ville ' +
+                'den almindelige profils cookies blive leveret i stedet.',
+        };
+      }
+      const vaertsnavne = sider.map((x) => x.vaert);
+      // Argumentet normaliseres som fanens adresse - "bücher.example" ER xn--bcher-kva.example.
+      let d = params.domain.trim().toLowerCase().replace(/^\.+/, '');
+      try { if (d) d = new URL('http://' + d + '/').hostname; } catch {}
+      const slaegt = (a, b) => a === b || a.endsWith('.' + b) || b.endsWith('.' + a);
+      if (!d || !vaertsnavne.some((h) => slaegt(h, d))) {
+        return {
+          ok: false, error: 'domaene-ikke-i-sessionen', domain: d, aabne: vaertsnavne,
+          hint: 'Cookies kan kun laeses for http(s)-sider denne session har aabne. Naviger til ' +
+                'siden foerst - saa kan agenten ikke laese cookies fra noget den ikke arbejder med.',
+        };
+      }
+      // Noeglen er et JSON-array, saa "a|b" i sti og navn ikke kan laegge to cookies sammen til én.
+      const fundne = new Map();
+      const med = (c, storeId) => {
+        const cd = String(c.domain || '').toLowerCase().replace(/^\./, '');
+        if (slaegt(cd, d)) fundne.set(JSON.stringify([storeId ?? '', c.domain, c.path, c.name]), c);
+      };
+      for (const side of sider) {
+        const lager = side.storeId ? { storeId: side.storeId } : {};
+        // Fable (sign-off 11/9): en session paa http:// fik en Secure-cookie fra overdomaenet. {url} udelader dem selv,
+        // men opslagene paa {domain} kender ikke sidens protokol. Chrome sender aldrig en Secure-cookie til http.
+        // Astra (efterproevning af c1496d4): Chromium regner localhost for sikker og sender Secure-cookies dertil over http.
+        const sikkerVaert = side.u.protocol === 'https:' || side.vaert === 'localhost' || side.vaert.endsWith('.localhost') ||
+          /^127(\.\d{1,3}){3}$/.test(side.vaert) || side.vaert === '[::1]';
+        const sendesOverProtokollen = (c) => !c.secure || sikkerVaert;
+        // De cookies Chrome ville SENDE til siden - inklusive overdomaenets ...
+        for (const c of await chrome.cookies.getAll({ url: side.u.href, ...lager })) med(c, side.storeId);
+        // ... plus sidens EGNE cookies paa alle stier (Path=/api kom ikke med ovenfor). {domain} giver
+        // ogsaa underdomaener og, for et public suffix, hele suffixet - saa kun cookies hvis domaene ER
+        // vaertsnavnet.
+        for (const c of await chrome.cookies.getAll({ domain: side.vaert, ...lager })) {
+          if (String(c.domain || '').toLowerCase().replace(/^\./, '') === side.vaert && sendesOverProtokollen(c)) med(c, side.storeId);
+        }
+        // MAALT 11/9 af Astra (R5 F7): overdomaenets cookie paa en anden sti (Domain=.example.com; Path=/api) kom
+        // med i 1.29.0, men ikke her: {url} giver kun sidens egen sti, og {domain: vaert} holdt kun cookies hvis
+        // domaene ER vaertsnavnet. Chrome spoerges nu ogsaa om det domaene der blev bedt om, og kun cookies som
+        // DENNE vaert ville faa tilsendt paa en eller anden sti beholdes. En host-only-cookie sendes kun til sin
+        // egen vaert, saa den skal passe praecist.
+        for (const c of await chrome.cookies.getAll({ domain: d, ...lager })) {
+          const cd = String(c.domain || '').toLowerCase().replace(/^\./, '');
+          const sendesTilVaerten = c.hostOnly ? side.vaert === cd : (side.vaert === cd || side.vaert.endsWith('.' + cd));
+          if (sendesTilVaerten && sendesOverProtokollen(c)) med(c, side.storeId);
+        }
+      }
+      return { cookies: [...fundne.values()].map(c => ({ name: c.name, value: c.value, domain: c.domain, path: c.path })) };
     }
 
     case 'get_local_storage': {
@@ -3220,12 +4220,64 @@ async function dispatch(port, method, params) {
     }
 
     case 'set_cookies': {
+      // MAALT 11/9 af Opus og Fable (e2e-review): laesningen er begraenset til sessionens egne sider, men skrivningen satte
+      // cookies paa ETHVERT domaene - ogsaa sider sessionen aldrig har aabnet (og butikkens begrundelse lovede det modsatte).
+      // Samme regel begge veje: kun de http(s)-vaerter sessionen har aabne.
+      // MAALT 11/9 (e2e runde 2): slaegtskabet blev laest BEGGE veje, saa en cookie til et uaabnet UNDERdomaene slap
+      // igennem (Astra), adressen kom fra kalderen i stedet for sessionens side (Opus), og en inkognitofane skrev i den
+      // almindelige profils lager (Opus). Reglen er nu laesningens: cookiens domaene skal vaere vaerten selv eller et
+      // overdomaene vaerten faar cookies fra, adressen bygges af sidens egen oprindelse (saa Chrome haandhaever bl.a.
+      // public suffix), og lageret foelger fanen.
+      const saetSession = getSession(port);
+      let saetUkendtLager = false;
+      let saetLagre = null;
+      try { saetLagre = await chrome.cookies.getAllCookieStores(); } catch {}
+      const saetSider = [];
+      for (const id of saetSession.tabIds) {
+        const t = await chrome.tabs.get(id).catch(() => null);
+        try {
+          const u = new URL(t?.url || '');
+          if ((u.protocol !== 'https:' && u.protocol !== 'http:') || !u.hostname) continue;
+          const storeId = (saetLagre || []).find((l) => (l.tabIds || []).includes(id))?.id;
+          if (t.incognito && !storeId) { saetUkendtLager = true; continue; }
+          saetSider.push({ u, vaert: u.hostname.toLowerCase(), storeId });
+        } catch {}
+      }
+      if (!saetSider.length && saetUkendtLager) {
+        return {
+          ok: false, error: 'cookie-lager-ukendt',
+          hint: 'Fanen er et inkognitovindue, og Chrome oplyste ikke dens cookie-lager. Intet blev skrevet - ellers ville ' +
+                'cookien lande i den almindelige profil i stedet.',
+        };
+      }
+      // Sidens vaert faar cookies fra sig selv og fra sine overdomaener - ikke fra et underdomaene den ikke har aabnet.
+      // MAALT 12/9 af Astra: `find` tog den FOERSTE fane der endte paa domaenet, saa en aaben a.example.com vandt over en
+      // lige saa aaben example.com - og adressen blev derefter bygget af den forkerte vaert. Den noejagtige vaert vinder nu.
+      // Slaegtskabs-stien (sidens vaert faar cookies fra sit overdomaene) kraever at kalderen SELV har sagt `domain`:
+      // uden `domain` er cookien host-only, og saa kan oensket ikke opfyldes fra et underdomaene.
+      const saetSideFor = (cd, eksplicitDomaene) =>
+        saetSider.find((s) => s.vaert === cd)
+        || (eksplicitDomaene ? saetSider.find((s) => s.vaert.endsWith('.' + cd)) : undefined);
       const results = [];
       const cookieList = Array.isArray(params.cookies) ? params.cookies : [params];
       for (const c of cookieList) {
+        let cd = String(c.domain || '').trim().toLowerCase().replace(/^\.+/, '');
+        if (!cd && c.url) { try { cd = new URL(c.url).hostname.toLowerCase(); } catch {} }
+        try { if (cd) cd = new URL('http://' + cd + '/').hostname; } catch {}
+        const side = cd ? saetSideFor(cd, Boolean(String(c.domain || '').trim())) : null;
+        if (!side) {
+          results.push({
+            ok: false, name: c.name, error: 'domaene-ikke-i-sessionen', domain: cd || null,
+            aabne: saetSider.map((s) => s.vaert),
+            hint: 'Cookies kan kun saettes for http(s)-sider denne session har aabne, og kun for sidens eget domaene ' +
+                  'eller - hvis du selv angiver domain - et overdomaene den faar cookies fra. Naviger til siden foerst.',
+          });
+          continue;
+        }
         try {
           const cookie = await chrome.cookies.set({
-            url: c.url || `https://${c.domain}`,
+            // Adressen bygges af sessionens egen side - saa Chrome selv haandhaever sine domaeneregler (public suffix osv.).
+            url: side.u.origin + (typeof c.path === 'string' && c.path.startsWith('/') ? c.path : '/'),
             name: c.name,
             value: c.value,
             domain: c.domain,
@@ -3233,6 +4285,7 @@ async function dispatch(port, method, params) {
             secure: c.secure !== false,
             httpOnly: c.httpOnly || false,
             sameSite: c.sameSite || 'lax',
+            ...(side.storeId ? { storeId: side.storeId } : {}),
           });
           results.push({ ok: true, name: c.name });
         } catch (e) {
@@ -3317,7 +4370,7 @@ async function dispatch(port, method, params) {
       chrome.notifications.create(notifId, {
         type: 'basic',
         iconUrl: 'icons/icon-128.png',
-        title: `${session.label} — Action Required`,
+        title: `${session.label} - Action Required`,
         message: params.message,
         requireInteraction: true,
         silent: false,
@@ -3378,7 +4431,7 @@ async function dispatch(port, method, params) {
 
             const h = document.createElement('div');
             h.style.cssText = 'font-size:14px;font-weight:600;color:#3b82f6;margin-bottom:4px';
-            h.textContent = title || 'Agent360 — Action Required';
+            h.textContent = title || 'Agent360 - Action Required';
             card.appendChild(h);
             const badge = document.createElement('div');
             badge.style.cssText = 'font-size:10px;color:#94a3b8;margin-bottom:12px';
@@ -3432,7 +4485,7 @@ async function dispatch(port, method, params) {
           });
         },
         // MAALT 21/8: her stod `params.title` raat. Skemaet siger at title er VALGFRI
-        // med standarden "Agent360 — Action Required", men udelades den, er vaerdien
+        // 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
@@ -3443,7 +4496,7 @@ async function dispatch(port, method, params) {
         // anvendes der hvor den er lovet.
         args: [
           String(params.message ?? ''),
-          String(params.title ?? 'Agent360 — Action Required'),
+          String(params.title ?? 'Agent360 - Action Required'),
           Array.isArray(fields) ? fields : [],
           Boolean(hasFields),
           Number(timeout) || 120000,
@@ -3510,7 +4563,23 @@ async function dispatch(port, method, params) {
       if (!lastCreatedTabId) return { error: 'No new tab detected' };
       try {
         const tab = await chrome.tabs.get(lastCreatedTabId);
-        // Claim the new tab for this session
+        // Kun faner der er aabnet FRA en af sessionens egne faner. Uden det her overtog
+        // agenten enhver fane brugeren selv havde aabnet — se kommentaren ved onCreated.
+        const session = getSession(port);
+        const opener = tab.openerTabId ?? openerForFane.get(tab.id) ?? null;
+        // Aabneren i sessionen NU, eller sessionen der ejede aabneren da fanen blev oprettet
+        // (aabneren kan vaere lukket siden - se ejerForFane ved onCreated).
+        const voresNu = opener != null && session.tabIds.has(opener);
+        const voresDaDenBlevAabnet = opener != null && ejerForFane.get(tab.id) === port;
+        if (!voresNu && !voresDaDenBlevAabnet) {
+          return {
+            error: 'not-ours',
+            hint: 'Den seneste nye fane blev ikke aabnet fra en af dine egne faner, saa den ' +
+                  'tilhoerer brugeren. Brug browser_navigate(new_tab: true) hvis du selv skal ' +
+                  'have en ny fane.',
+            tab_id: tab.id,
+          };
+        }
         await addTabToSession(port, tab.id);
         return { id: tab.id, url: tab.url, title: tab.title };
       } catch {
@@ -3524,9 +4593,24 @@ async function dispatch(port, method, params) {
         throw new Error(`Tab ${params.tab_id} does not belong to this session (${session.label})`);
       }
       const tab = await chrome.tabs.update(params.tab_id, { active: true });
+      // Gør ogsaa VINDUET forrest. Uden det bliver fanen aktiv inde i sit vindue —
+      // document.hasFocus() bliver sand — men document.visibilityState forbliver
+      // 'hidden' fordi vinduet ligger bagved. Chrome struber timere i skjulte
+      // faner, saa Angular-apps (Google Ads, GA4, Search Console) renderer aldrig
+      // faerdigt: man laeser en halvt bygget side og drager forkerte konklusioner.
+      // Kostede to opgaver og en forkert konklusion 31/8-2026.
+      let vinduesFokus = null;
+      try {
+        await chrome.windows.update(tab.windowId, { focused: true });
+        vinduesFokus = true;
+      } catch (e) {
+        // Vinduet kan vaere lukket eller paa et andet Space. Fanen er stadig
+        // aktiv; vi siger bare aerligt at synligheden ikke kunne sikres.
+        vinduesFokus = false;
+      }
       session.activeTabId = tab.id;
       persistSessions();
-      return { id: tab.id, url: tab.url, title: tab.title };
+      return { id: tab.id, url: tab.url, title: tab.title, windowFocused: vinduesFokus };
     }
 
     case 'close_tab': {
@@ -3590,7 +4674,7 @@ async function dispatch(port, method, params) {
         const { result: nodeResult } = await cdpSend(tab.id, 'Runtime.evaluate', {
           expression: `(() => {
             const el = document.querySelector(${JSON.stringify(selector)});
-            if (!el) return JSON.stringify({ found: false, error: 'File input not found: ${selector}' });
+            if (!el) return JSON.stringify({ found: false, error: 'File input not found: ' + ${JSON.stringify(selector)} });
             return JSON.stringify({ found: true, tag: el.tagName, type: el.type, accept: el.accept, multiple: el.multiple });
           })()`,
           returnByValue: true,
@@ -3864,6 +4948,8 @@ chrome.runtime.onStartup.addListener(() => ensureOffscreen().catch(console.error
 // 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 () => {
+  // Foerst: aeldre udgaver gemte parametre (adgangskoder, cookie-vaerdier) i historikken.
+  await rensHandlingslog();
   try {
     if (await chrome.offscreen.hasDocument()) await chrome.offscreen.closeDocument();
   } catch (e) {
@@ -3898,4 +4984,33 @@ chrome.alarms.onAlarm.addListener((alarm) => {
   if (alarm.name === 'ensure-offscreen') {
     ensureOffscreen().catch(console.error);
   }
+  if (alarm.name.startsWith('frigiv-')) {
+    const port = Number(alarm.name.slice('frigiv-'.length));
+    // ── Hvorfor lageret laeses DIREKTE og ikke via restoreSessions() ─────────
+    //
+    // FUNDET AF REVIEW 7/9. Her stod `restoreSessions().then(...)`, og kommentaren
+    // sagde at det var vaernet mod en genstartet service-worker. Den gjorde det
+    // modsatte: `restoreSessions()` gendanner kun sessioner der har GYLDIGE FANER
+    // (`if (validTabIds.size > 0)`) — og en tom session er praecis den her alarm
+    // handler om. En MV3-worker suspenderes efter ~30 sekunder; fristen er paa fem
+    // minutter, saa workeren er naesten altid frisk naar alarmen fyrer. Sessionen
+    // blev derfor aldrig fundet, `if (!s) return` ramte, og porten blev holdt til
+    // 4-timers-tomgangen — altsaa praecis den fejl frigivelsen skulle fjerne.
+    //
+    // restoreSessions() har god grund til ikke at genoplive doede sessioner (andre
+    // kaldere vil ikke arve faner der ikke findes). Derfor rettes det HER.
+    (async () => {
+      const iHukommelsen = sessions.get(port);
+      if (iHukommelsen) {
+        if (iHukommelsen.tabIds.size > 0) return;   // den arbejder igen — lad den vaere
+      } else {
+        const { sessions: gemte } = await chrome.storage.local.get({ sessions: {} });
+        const gemt = gemte[String(port)];
+        if (!gemt) return;                          // sessionen er reelt vaek
+        if ((gemt.tabIds || []).length > 0) return; // den arbejder igen
+      }
+      frivilligtFrigivet.add(port);
+      chrome.runtime.sendMessage({ type: 'terminate_mcp_session', port }).catch(() => {});
+    })().catch(() => {});
+  }
 });