eddie-jekyll 0.4.1 → 0.4.2

data/assets/eddie-widget.js

@@ -2,6 +2,7 @@
 // Generated by widget/build.sh from widget/src/eddie-widget.js and widget/src/lib/*.js; edit those instead.
 (function () {
 "use strict";
+const EDDIE_ASSET_VERSION = "c0fdc503e01a";
 const EddieLib = {};
 // SPDX-License-Identifier: GPL-3.0-only
 
@@ -60,8 +61,10 @@ const EddieLib = {};
       answerTopK: intAttr(get("data-answer-top-k"), 5),
       agentMode: oneOf(get("data-agent-mode"), ["off", "auto"], "auto"),
       agentModel: agentModelRaw === "" ? "auto" : agentModelRaw,
-      denseRuntime: oneOf(get("data-dense-runtime"), ["auto", "wasm", "webgpu"], "auto"),
+      denseRuntime: oneOf(get("data-dense-runtime"), ["auto", "wasm", "webgpu", "off"], "auto"),
       consentText: (get("data-consent-text") || "").trim(),
+      persist: oneOf(get("data-persist"), ["auto", "off"], "auto"),
+      warm: oneOf(get("data-warm"), ["auto", "off", "always"], "auto"),
     };
   }
 
@@ -70,6 +73,274 @@ const EddieLib = {};
 
 // SPDX-License-Identifier: GPL-3.0-only
 
+// Visitor preferences: which search model to download, which agent model to
+// run, and how eagerly to load either. Pure functions over the site's
+// `data-*` config, the index's lane list and what the browser can run.
+//
+// The site config is the ceiling: a visitor can always choose less, and can
+// choose among what the site left open, but cannot switch on what the owner
+// turned off. `settingsChoices` is where that rule lives. `effectiveConfig`
+// drops a preference that is no longer on offer -- a re-indexed site, a
+// different browser, a changed `data-*` -- so a stale one degrades to the
+// site default instead of breaking the widget.
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  const SETTINGS_KEY = "eddie.settings";
+
+  // Ladders, least eager first: a visitor may pick any rung up to and
+  // including the site's.
+  const WARM_RUNGS = ["off", "auto", "always"];
+  const PERSIST_RUNGS = ["off", "auto"];
+  // The two named agent sizes selectAgentModel understands.
+  const AGENT_LEVELS = ["light", "quality"];
+
+  const FIELDS = ["searchLane", "agentLevel", "warm", "persist"];
+
+  /** Stored preferences, or {} when there are none, the value is unusable, or storage is unavailable. */
+  function readSettings(storage) {
+    let raw = null;
+    try {
+      raw = storage && storage.getItem ? storage.getItem(SETTINGS_KEY) : null;
+    } catch (_) {
+      return {};
+    }
+    if (!raw) return {};
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (_) {
+      return {};
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const out = {};
+    for (const f of FIELDS) {
+      if (typeof parsed[f] === "string" && parsed[f]) out[f] = parsed[f];
+    }
+    return out;
+  }
+
+  /** Merge `patch` into the stored preferences and persist. Returns the merged object. */
+  function writeSettings(storage, patch) {
+    const merged = Object.assign(readSettings(storage), patch || {});
+    for (const k of Object.keys(merged)) {
+      if (merged[k] == null || merged[k] === "") delete merged[k];
+    }
+    try {
+      if (storage && storage.setItem) storage.setItem(SETTINGS_KEY, JSON.stringify(merged));
+    } catch (_) {
+      // storage unavailable: the choice applies to this page and is forgotten
+    }
+    return merged;
+  }
+
+  function clearSettings(storage) {
+    try {
+      if (storage && storage.removeItem) storage.removeItem(SETTINGS_KEY);
+    } catch (_) {
+      // nothing to do
+    }
+    return {};
+  }
+
+  /** Rungs of a ladder up to and including the site's value (which is the ceiling). */
+  function rungsUpTo(rungs, siteValue, fallback) {
+    const at = rungs.indexOf(siteValue);
+    return rungs.slice(0, (at < 0 ? rungs.indexOf(fallback) : at) + 1);
+  }
+
+  /** A lane the site's `data-dense-runtime` allows (`auto` allows both kinds). */
+  function laneAllowedByRuntime(lane, denseRuntime) {
+    if (denseRuntime === "off") return false;
+    if (denseRuntime === "wasm") return lane.kind === "wasm-candle";
+    if (denseRuntime === "webgpu") return lane.kind === "webgpu-onnx";
+    return true;
+  }
+
+  /**
+   * What the settings panel may offer.
+   *
+   * o: { config, lanes, hostSkipped, hasWebGpu }, where `lanes` is null
+   * before the engine has read the index.
+   *
+   * `search` and `agent` are null while `lanes` is: at mount there is neither
+   * a lane list nor an adapter probe, and answering "no options" then would
+   * throw away a valid stored preference. `warm` and `persist` need only the
+   * site config. Every non-null group is a list of `{ value, label, detail }`
+   * containing the least-eager option, so the panel renders a radio group
+   * without special cases.
+   */
+  function settingsChoices(o) {
+    const opts = o || {};
+    const config = opts.config || {};
+    const lanesKnown = Array.isArray(opts.lanes);
+    const lanes = lanesKnown ? opts.lanes : [];
+    const skipped = new Set(Array.isArray(opts.hostSkipped) ? opts.hostSkipped : []);
+    const hasWebGpu = !!opts.hasWebGpu;
+
+    const search = [{ value: "none", label: "Keyword only", detail: "No model download" }];
+    for (const lane of lanes) {
+      if (!lane || !lane.id || skipped.has(lane.id)) continue;
+      if (!laneAllowedByRuntime(lane, config.denseRuntime || "auto")) continue;
+      if (lane.kind === "webgpu-onnx" && !hasWebGpu) continue;
+      search.push({
+        value: lane.id,
+        label: lane.model || lane.id,
+        detail: lane.kind === "webgpu-onnx" ? "WebGPU" : "CPU",
+        origin: lane.origin || null,
+        kind: lane.kind || null,
+      });
+    }
+
+    // WebLLM needs a WebGPU adapter, so without one the agent is not on offer
+    // however the site is configured.
+    const agent = [{ value: "off", label: "Off", detail: "No agent download" }];
+    const pinned = String(config.agentModel || "auto").trim();
+    if (config.agentMode !== "off" && hasWebGpu) {
+      if (pinned && pinned !== "auto" && AGENT_LEVELS.indexOf(pinned) < 0) {
+        // The site pinned one WebLLM model id: offer that, or nothing.
+        agent.push({ value: pinned, label: pinned, detail: "Chosen by this site" });
+      } else {
+        agent.push({ value: "light", label: "Light", detail: "Smaller model, faster, less accurate" });
+        agent.push({ value: "quality", label: "Quality", detail: "Larger model, slower, better answers" });
+      }
+    }
+
+    const warm = rungsUpTo(WARM_RUNGS, config.warm, "auto").map((value) => ({
+      value,
+      label: value === "off" ? "On demand" : value === "auto" ? "When I've searched before" : "Always",
+      detail:
+        value === "off"
+          ? "Load search when I first search"
+          : value === "auto"
+            ? "Preload on pages I visit after my first search here"
+            : "Preload on every page view",
+    }));
+
+    const persist = rungsUpTo(PERSIST_RUNGS, config.persist, "auto").map((value) => ({
+      value,
+      label: value === "off" ? "Per page" : "Across pages",
+      detail:
+        value === "off"
+          ? "Reload the engine on every page"
+          : "Keep the engine in a service worker so other pages start instantly",
+    }));
+
+    return { search: lanesKnown ? search : null, agent: lanesKnown ? agent : null, warm, persist };
+  }
+
+  /** Would the site config allow this search preference, lanes aside? */
+  function searchWithinCeiling(config, value) {
+    if (!value) return false;
+    if (value === "none") return true;
+    return ((config || {}).denseRuntime || "auto") !== "off";
+  }
+
+  /** Would the site config allow this agent preference, adapter aside? */
+  function agentWithinCeiling(config, value) {
+    if (!value) return false;
+    if (value === "off") return true;
+    return (config || {}).agentMode !== "off";
+  }
+
+  /**
+   * What a group shows: the stored preference if it is still on offer, else
+   * the site default, else the least-eager option -- never the heaviest, so a
+   * panel opened before the engine reports a lane does not imply the biggest
+   * model is already running.
+   */
+  function selected(group, stored, fallback) {
+    const has = (v) => group.some((c) => c.value === v);
+    if (stored && has(stored)) return stored;
+    if (fallback && has(fallback)) return fallback;
+    return group.length ? group[0].value : null;
+  }
+
+  /**
+   * Which option each group is on. `searchLane` and `agentLevel` have no site
+   * default, so the lane the engine actually loaded stands in for the first
+   * and the site's `agentModel` for the second.
+   */
+  function currentSelection(choices, settings, o) {
+    const c = choices || {};
+    const s = settings || {};
+    const opts = o || {};
+    const config = opts.config || {};
+    // With the site on `auto` the level is whatever selectAgentModel picked
+    // for this adapter, so show that rather than guessing "quality".
+    const agentFallback = (function () {
+      const pinned = String(config.agentModel || "auto").trim();
+      if (pinned && pinned !== "auto") return pinned;
+      return opts.activeAgent || "quality";
+    })();
+    return {
+      searchLane: selected(c.search || [], s.searchLane, opts.activeLane || null),
+      agentLevel: selected(c.agent || [], s.agentLevel, agentFallback),
+      warm: selected(c.warm || [], s.warm, config.warm),
+      persist: selected(c.persist || [], s.persist, config.persist),
+    };
+  }
+
+  /**
+   * The site config with the visitor's preferences applied. Preferences that
+   * are no longer on offer are ignored, so the result is always something the
+   * engine and the transport can act on.
+   */
+  function effectiveConfig(config, settings, choices) {
+    const base = Object.assign({}, config || {});
+    const c = choices || {};
+    const s = settings || {};
+    // A group the widget does not know yet (no lane list at mount) falls back
+    // to the site ceiling: the engine validates a pinned lane anyway and
+    // reports it if the lane cannot run here.
+    const allowed = (group, v, ceiling) =>
+      !!v && (group ? group.some((x) => x.value === v) : ceiling(config, v));
+
+    if (allowed(c.search, s.searchLane, searchWithinCeiling)) {
+      if (s.searchLane === "none") {
+        base.denseRuntime = "off";
+        base.laneId = null;
+      } else {
+        base.laneId = s.searchLane;
+        if (base.denseRuntime === "off") base.denseRuntime = "auto";
+      }
+    }
+    if (allowed(c.agent, s.agentLevel, agentWithinCeiling)) {
+      if (s.agentLevel === "off") {
+        base.agentMode = "off";
+      } else {
+        base.agentMode = "auto";
+        base.agentModel = s.agentLevel;
+      }
+    }
+    if (allowed(c.warm, s.warm, () => false)) base.warm = s.warm;
+    if (allowed(c.persist, s.persist, () => false)) base.persist = s.persist;
+    return base;
+  }
+
+  return {
+    SETTINGS_KEY,
+    readSettings,
+    writeSettings,
+    clearSettings,
+    settingsChoices,
+    currentSelection,
+    effectiveConfig,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
 // URL, version and cache-key helpers shared by the widget and the worker.
 
 (function (factory) {
@@ -86,6 +357,17 @@ const EddieLib = {};
 
   const HF_HOST = "https://huggingface.co";
 
+  /**
+   * `?v=` of the runtime assets (widget, workers, wasm, glue, service
+   * workers): a hash of the files that produced them, stamped into every
+   * bundle by widget/build.sh. Deliberately not the index's version, which
+   * changes on every content rebuild and so re-downloaded the whole engine
+   * on every deploy; see "Script tag" in widget/README.md. null outside a
+   * bundle (the Node tests), which just means no `?v=`.
+   */
+  const ASSET_VERSION =
+    typeof EDDIE_ASSET_VERSION === "string" && EDDIE_ASSET_VERSION ? EDDIE_ASSET_VERSION : null;
+
   /** Directory of an absolute URL, without query or hash, with a trailing slash. */
   function baseUrlOf(href) {
     const u = new URL(href);
@@ -153,6 +435,7 @@ const EddieLib = {};
 
   return {
     HF_HOST,
+    ASSET_VERSION,
     baseUrlOf,
     versionOf,
     withVersion,
@@ -167,8 +450,10 @@ const EddieLib = {};
 
 // SPDX-License-Identifier: GPL-3.0-only
 
-// Dense-lane selection, download sizes, consent copy and degraded-arm notices.
-// Pure functions over the index manifest (see src/manifest.rs).
+// User-facing copy shared by the widget and the search engine: byte
+// formatting, the download consent card and the degraded-arm notices.
+// Split out of lanes.js so the widget bundle carries only this, not the
+// engine-side lane selection.
 
 (function (factory) {
   const api = factory();
@@ -182,128 +467,6 @@ const EddieLib = {};
 })(function () {
   "use strict";
 
-  const DEFAULT_WASM_FILES = ["config.json", "tokenizer.json", "model.safetensors"];
-
-  // Approximate download sizes (bytes) keyed by lower-cased HuggingFace repo.
-  const DOWNLOAD_SIZES = {
-    "sentence-transformers/multi-qa-minilm-l6-cos-v1": 91e6,
-    "sentence-transformers/all-minilm-l6-v2": 91e6,
-    "sentence-transformers/all-minilm-l12-v2": 134e6,
-    "sentence-transformers/paraphrase-multilingual-minilm-l12-v2": 471e6,
-    "baai/bge-small-en-v1.5": 134e6,
-    "baai/bge-base-en-v1.5": 438e6,
-    "onnx-community/qwen3-embedding-0.6b-onnx": 900e6,
-    "onnx-community/harrier-oss-v1-0.6b-onnx": 400e6,
-    "xenova/bge-m3": 570e6,
-  };
-
-  function laneKind(lane) {
-    return lane && lane.runtime ? lane.runtime.kind : null;
-  }
-
-  function isWasmLane(lane) {
-    return laneKind(lane) === "wasm-candle";
-  }
-
-  function isWebGpuLane(lane) {
-    return laneKind(lane) === "webgpu-onnx";
-  }
-
-  /** Repo the runtime downloads from. */
-  function laneRepo(lane) {
-    if (isWebGpuLane(lane)) return lane.runtime.repo;
-    return lane.model;
-  }
-
-  /**
-   * HuggingFace revision for the runtime's downloads. `lane.revision` pins
-   * `lane.model` (the repo the indexer used); a webgpu-onnx lane downloads
-   * from a different repo (`runtime.repo`) that the manifest does not pin.
-   */
-  function laneRevision(lane) {
-    if (isWebGpuLane(lane)) return "main";
-    return lane.revision || "main";
-  }
-
-  /** Files a wasm-candle lane needs (config, tokenizer, weights). */
-  function laneFiles(lane) {
-    if (!isWasmLane(lane)) return [];
-    const files = Array.isArray(lane.runtime.files) ? lane.runtime.files : [];
-    return files.length ? files.slice() : DEFAULT_WASM_FILES.slice();
-  }
-
-  function isWeightsFile(file) {
-    return /\.(safetensors|bin|pt|gguf|onnx)$/i.test(String(file));
-  }
-
-  /**
-   * Why the WASM loader (init_dense_wasm) cannot run a wasm-candle lane, or
-   * null when it can: it accepts BERT-family lanes with config.json,
-   * tokenizer.json and exactly one unsharded model.safetensors.
-   */
-  function wasmLaneProblem(lane) {
-    if (!isWasmLane(lane)) return "not a wasm-candle lane";
-    if (lane.family && lane.family !== "bert") return `family ${lane.family} is not supported in WASM`;
-    const files = laneFiles(lane);
-    for (const need of ["config.json", "tokenizer.json"]) {
-      if (!files.includes(need)) return `runtime.files lacks ${need}`;
-    }
-    const weights = files.filter(isWeightsFile);
-    if (weights.length === 1 && weights[0] === "model.safetensors") return null;
-    if (weights.length === 0) return "runtime.files lists no weights file";
-    return `WASM needs a single model.safetensors, not ${weights.join(", ")}`;
-  }
-
-  /**
-   * Ordered dense-lane candidates for this browser, plus the lanes skipped
-   * because this runtime cannot load them (`skipped: [{lane, reason}]`).
-   * `denseRuntime`: "auto" | "wasm" | "webgpu"; `hasWebGpu`: an adapter was obtained.
-   */
-  function chooseDenseLanes(manifest, opts) {
-    const lanes = (manifest && Array.isArray(manifest.dense)) ? manifest.dense : [];
-    const runtime = (opts && opts.denseRuntime) || "auto";
-    const hasWebGpu = !!(opts && opts.hasWebGpu);
-    const webgpu = lanes.filter(isWebGpuLane);
-    const skipped = [];
-    const wasm = lanes.filter(isWasmLane).filter((lane) => {
-      const problem = wasmLaneProblem(lane);
-      if (problem) skipped.push({ lane, reason: problem });
-      return !problem;
-    });
-    if (lanes.length === 0) {
-      return { candidates: [], skipped, reason: "index has no dense lane" };
-    }
-    let candidates;
-    if (runtime === "wasm") {
-      candidates = wasm;
-    } else if (runtime === "webgpu") {
-      candidates = hasWebGpu ? webgpu : [];
-    } else {
-      candidates = hasWebGpu ? webgpu.concat(wasm) : wasm;
-    }
-    let reason = null;
-    if (candidates.length === 0) {
-      if (runtime === "wasm") reason = skipped.length ? "no wasm-candle lane the WASM loader can run" : "index has no wasm-candle lane";
-      else if (!hasWebGpu && webgpu.length && !wasm.length) reason = "no WebGPU adapter";
-      else if (runtime === "webgpu" && !hasWebGpu) reason = "no WebGPU adapter";
-      else if (runtime === "webgpu") reason = "index has no webgpu-onnx lane";
-      else reason = "no runnable dense lane";
-    }
-    return { candidates, skipped, reason };
-  }
-
-  /** transformers.js dtype for a webgpu-onnx lane on this adapter. */
-  function pickDtype(runtime, hasF16) {
-    if (hasF16 && runtime.dtype_f16) return runtime.dtype_f16;
-    return runtime.dtype || "fp32";
-  }
-
-  /** Approximate bytes a lane downloads on first use, or null when unknown. */
-  function laneDownloadBytes(lane) {
-    const repo = (laneRepo(lane) || "").toLowerCase();
-    return Object.prototype.hasOwnProperty.call(DOWNLOAD_SIZES, repo) ? DOWNLOAD_SIZES[repo] : null;
-  }
-
   function formatBytes(n) {
     if (n == null || !Number.isFinite(n)) return "unknown size";
     if (n >= 1e9) {
@@ -317,16 +480,21 @@ const EddieLib = {};
 
   /**
    * Consent card copy for a model download. `consentText` (site override) may
-   * contain `{size}` and `{model}` placeholders.
+   * contain `{size}`, `{model}` and `{origin}` placeholders.
+   *   sizeBytes    model download (null when unknown)
+   *   origin       "site" | "huggingface" (where the model is fetched from)
+   *   sidecarBytes index vectors fetched from the site for this lane (0 when in the core index)
    */
   function consentCopy(opts) {
     const size = formatBytes(opts.sizeBytes);
     const model = opts.model || "the search model";
+    const origin = opts.origin === "site" ? "this site" : "huggingface.co";
     if (opts.consentText) {
-      return opts.consentText.replace(/\{size\}/g, size).replace(/\{model\}/g, model);
+      return opts.consentText.replace(/\{size\}/g, size).replace(/\{model\}/g, model).replace(/\{origin\}/g, origin);
     }
-    const sized = opts.sizeBytes == null ? "a one-time download (size unknown)" : `a one-time ${size} download`;
-    let text = `Semantic search runs a language model in your browser. That needs ${sized} of ${model}, kept in your browser's cache for next time.`;
+    const sized = opts.sizeBytes == null ? `a one-time download (size unknown) from ${origin}` : `a one-time ${size} download from ${origin}`;
+    const side = opts.sidecarBytes > 0 ? `, plus ${formatBytes(opts.sidecarBytes)} of index vectors from this site` : "";
+    let text = `Semantic search runs ${model} in your browser. That needs ${sized}${side}, kept in your browser's cache for next time.`;
     if (opts.saveData) {
       text = "Data saver is on. " + text;
     }
@@ -337,8 +505,15 @@ const EddieLib = {};
    * Drop degraded notes that describe the index design rather than a failure
    * (an index without a dense lane or sparse arm is not "degraded").
    */
+  /**
+   * Drop the "degraded" entries that describe how the index or the visitor
+   * chose to run, not something going wrong: an index built without a lane,
+   * and a visitor who picked keyword-only search in the settings panel.
+   */
   function filterDesignDegraded(degraded) {
-    return (degraded || []).filter((d) => !/index has no (dense lane|sparse arm)/.test(d));
+    return (degraded || []).filter(
+      (d) => !/index has no (dense lane|sparse arm)|dense search is turned off/.test(d)
+    );
   }
 
   /** Human notice when a semantic arm is missing, or null when nothing to say. */
@@ -356,19 +531,6 @@ const EddieLib = {};
   }
 
   return {
-    DEFAULT_WASM_FILES,
-    DOWNLOAD_SIZES,
-    laneKind,
-    isWasmLane,
-    isWebGpuLane,
-    laneRepo,
-    laneRevision,
-    laneFiles,
-    isWeightsFile,
-    wasmLaneProblem,
-    chooseDenseLanes,
-    pickDtype,
-    laneDownloadBytes,
     formatBytes,
     consentCopy,
     filterDesignDegraded,
@@ -378,9 +540,10 @@ const EddieLib = {};
 
 // SPDX-License-Identifier: GPL-3.0-only
 
-// Agent helpers shared by the widget and the agent worker: model selection,
-// prompts, plan parsing, evidence assembly and answer post-processing.
-// Pure functions; no WebLLM, no DOM.
+// Agent helpers the widget shows in its UI: model selection, evidence
+// assembly, stream display and the FAQ gate. Pure functions; no WebLLM, no
+// DOM. The prompts and answer post-processing that run beside the model
+// live in agent-llm.js (bundled only into the agent engine's hosts).
 
 (function (factory) {
   const api = factory();
@@ -395,7 +558,6 @@ const EddieLib = {};
   "use strict";
 
   const NOHIT = "The site doesn't cover that.";
-  const NOHIT_RE = /\bthe site (?:doesn['’]t|does not|didn['’]t|did not) cover (?:that|this|it)\.?/gi;
 
   const AGENT_MODEL_SIZES = {
     "Qwen3.5-0.8B": 0.4e9,
@@ -404,22 +566,6 @@ const EddieLib = {};
   };
   const TWO_GIB = 2 * 1024 * 1024 * 1024;
 
-  const PLAN_SCHEMA = {
-    type: "object",
-    properties: {
-      queries: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 3 },
-    },
-    required: ["queries"],
-  };
-
-  function planPrompt(site) {
-    return `You write search queries for a site search engine. The site is ${site}. Reply with JSON only: {"queries": ["..."]}. Give 1 to 3 different short keyword queries (2 to 5 words each, no punctuation) that a site search engine would match against page text. Each query must be different. Do not answer the question.`;
-  }
-
-  function answerPrompt(site) {
-    return `You answer visitor questions about ${site} using only the numbered sources below the question. Answer the question directly in the first sentence. Write 1 to 3 sentences in your own words; never repeat a source's wording. End each sentence with the numbers of the sources it comes from, like [2] or [1][3]. Never cite a number that is not in the list. Do not add calculations or inferences that are not in the sources. If no source answers the question, your entire reply is: ${NOHIT} Never mix that sentence with an answer. Never use outside knowledge.`;
-  }
-
   /** Strip the WebLLM variant suffix to get the family name shown to visitors. */
   function baseModelId(id) {
     return String(id).replace(/-q\d+f(16|32)_\d+-MLC$/i, "");
@@ -432,7 +578,10 @@ const EddieLib = {};
 
   /**
    * Choose the WebLLM model id.
-   * opts: { mode: "auto"|"quality"|<id>, maxBufferSize, isMobile, hasF16 }
+   * opts: { mode: "auto"|"light"|"quality"|<id>, maxBufferSize, isMobile, hasF16 }
+   *
+   * "light" and "quality" are the two sizes the settings panel offers by
+   * name; "auto" picks between them from the adapter's buffer limit.
    */
   function selectAgentModel(opts) {
     const o = opts || {};
@@ -444,6 +593,8 @@ const EddieLib = {};
       base = big ? "Qwen3.5-2B" : "Qwen3.5-0.8B";
     } else if (mode === "quality") {
       base = "Qwen3.5-2B";
+    } else if (mode === "light") {
+      base = "Qwen3.5-0.8B";
     } else {
       return { id: mode, base: baseModelId(mode), sizeBytes: agentModelBytes(mode), explicit: true };
     }
@@ -459,14 +610,6 @@ const EddieLib = {};
     return /Mobi|Android|iPhone|iPad|iPod|Windows Phone/i.test(n.userAgent || "");
   }
 
-  /** Remove <think>…</think> blocks; a dangling <think> loses only the tag. */
-  function stripThink(text) {
-    if (!text) return "";
-    let out = String(text).replace(/<think>[\s\S]*?<\/think>/g, "");
-    out = out.replace(/<think>/g, "").replace(/<\/think>/g, "");
-    return out.trim();
-  }
-
   /**
    * Display text for a partial stream: complete think blocks removed, and
    * anything after an unclosed <think> hidden until it closes.
@@ -479,50 +622,6 @@ const EddieLib = {};
     return out.replace(/^\s+/, "");
   }
 
-  function extractJsonObject(text) {
-    const s = String(text);
-    const start = s.indexOf("{");
-    const end = s.lastIndexOf("}");
-    if (start < 0 || end <= start) return null;
-    try {
-      return JSON.parse(s.substring(start, end + 1));
-    } catch (_) {
-      return null;
-    }
-  }
-
-  function cleanQuery(q) {
-    return String(q)
-      .replace(/\/?no_think/gi, "")
-      .replace(/[\s"'`*]+$/g, "")
-      .replace(/^[\s"'`*\-\d.)]+/g, "")
-      .replace(/\s+/g, " ")
-      .trim();
-  }
-
-  /** Parse the planner reply into 1..3 distinct queries; falls back to the question. */
-  function parsePlan(text, question) {
-    const cleaned = stripThink(text);
-    const obj = extractJsonObject(cleaned);
-    const raw = obj && Array.isArray(obj.queries) ? obj.queries : [];
-    const seen = new Set();
-    const out = [];
-    for (const item of raw) {
-      if (typeof item !== "string") continue;
-      const q = cleanQuery(item);
-      if (q.length < 2 || q.length > 80) continue;
-      const key = q.toLowerCase();
-      if (seen.has(key)) continue;
-      seen.add(key);
-      out.push(q);
-      if (out.length === 3) break;
-    }
-    if (out.length === 0 && question && question.trim()) {
-      out.push(question.trim());
-    }
-    return out;
-  }
-
   function urlKey(url) {
     return String(url || "").replace(/#.*$/, "").replace(/\/+$/, "").toLowerCase();
   }
@@ -551,95 +650,6 @@ const EddieLib = {};
     return out;
   }
 
-  /** Cut to `max` characters at a word boundary, with an ellipsis. */
-  function truncateText(text, max) {
-    const limit = max == null ? 700 : max;
-    const s = String(text || "").replace(/\s+/g, " ").trim();
-    if (s.length <= limit) return s;
-    const cut = s.lastIndexOf(" ", limit - 1);
-    return s.substring(0, cut > limit * 0.6 ? cut : limit - 1).trim() + "…";
-  }
-
-  /** `[n] title (url)\ntext` blocks joined by blank lines. */
-  function formatEvidence(items, maxChars) {
-    return (items || [])
-      .map((e, i) => `[${i + 1}] ${e.title || e.url} (${e.url})\n${truncateText(e.text || e.snippet || "", maxChars)}`)
-      .join("\n\n");
-  }
-
-  function sourcesPrompt(items, question, maxChars) {
-    return `Sources:\n\n${formatEvidence(items, maxChars)}\n\nQuestion: ${question}`;
-  }
-
-  /**
-   * Post-process a raw model answer against the evidence list.
-   * Returns { answer, citations: [{n, url, title}], nohit }.
-   */
-  function postProcessAnswer(raw, evidence) {
-    const ev = Array.isArray(evidence) ? evidence : [];
-    let text = stripThink(raw);
-    // **[1]** -> [1]
-    text = text.replace(/\*\*\s*((?:\[\s*\d+(?:\s*,\s*\d+)*\s*\]\s*)+)\*\*/g, "$1");
-    // Lines that are only citation markers belong to the previous line.
-    const lines = text.split(/\r?\n/);
-    const merged = [];
-    for (const line of lines) {
-      const t = line.trim();
-      if (t && /^(?:\[\s*\d+(?:\s*,\s*\d+)*\s*\]\s*)+$/.test(t)) {
-        let j = merged.length - 1;
-        while (j >= 0 && merged[j].trim() === "") j--;
-        if (j >= 0) {
-          // Append only markers the previous line does not already carry.
-          const prev = merged[j];
-          const fresh = (t.match(/\[\s*\d+(?:\s*,\s*\d+)*\s*\]/g) || []).filter((m) => !prev.includes(m.replace(/\s+/g, "")));
-          merged.length = j + 1;
-          if (fresh.length) merged[j] = prev.replace(/\s+$/, "") + " " + fresh.join("");
-          continue;
-        }
-      }
-      merged.push(line);
-    }
-    text = merged.join("\n");
-
-    // Drop the fallback sentence when anything else remains.
-    const withoutFallback = text.replace(NOHIT_RE, "").replace(/[ \t]+\n/g, "\n").trim();
-    const residue = withoutFallback
-      .replace(/\[\s*\d+(?:\s*,\s*\d+)*\s*\]/g, "")
-      .replace(/^\s*(?:yes|no)\b/i, "")
-      .replace(/[\s.,;:!?'"*-]+/g, "");
-    const onlyFallback = residue === "";
-    if (onlyFallback) {
-      return { answer: NOHIT, citations: [], nohit: true };
-    }
-    text = withoutFallback;
-
-    // Map [n] citations to evidence; drop out-of-range ones.
-    const cited = [];
-    const seen = new Set();
-    text = text.replace(/\[\s*(\d+(?:\s*,\s*\d+)*)\s*\]/g, (_, body) => {
-      const nums = body.split(",").map((x) => Number(x.trim()));
-      let out = "";
-      for (const n of nums) {
-        if (n >= 1 && n <= ev.length) {
-          out += `[${n}]`;
-          if (!seen.has(n)) {
-            seen.add(n);
-            cited.push(n);
-          }
-        }
-      }
-      return out;
-    });
-    // Collapse duplicate adjacent markers ("[1][1]") and tidy whitespace.
-    text = text.replace(/(\[\d+\])(?:\s*\1)+/g, "$1");
-    text = text.replace(/[ \t]{2,}/g, " ").replace(/ +([.,;:!?])/g, "$1").replace(/\n{3,}/g, "\n\n").trim();
-    const citations = cited
-      .sort((a, b) => a - b)
-      .map((n) => ({ n, url: ev[n - 1].url, title: ev[n - 1].title || ev[n - 1].url }));
-    return { answer: text, citations, nohit: text === "" };
-  }
-
-
   // FAQ card gate: prefer the WASM's fused `confident` flag (qa_lookup v0.4.1+);
   // older indexes only carry a dense score, so fall back to a plain cutoff.
   function faqPasses(hit, qaMode) {
@@ -671,31 +681,614 @@ const EddieLib = {};
     qaEvidence,
     NOHIT,
     AGENT_MODEL_SIZES,
-    PLAN_SCHEMA,
-    planPrompt,
-    answerPrompt,
-    sourcesPrompt,
     baseModelId,
     agentModelBytes,
     selectAgentModel,
     isMobileDevice,
-    stripThink,
     visibleStreamText,
-    parsePlan,
     mergeEvidence,
-    truncateText,
-    formatEvidence,
-    postProcessAnswer,
   };
 });
 
 // SPDX-License-Identifier: GPL-3.0-only
 
+// Transports between the widget and its engines.
+//
+// DedicatedWorkerTransport wraps a Worker; ServiceWorkerTransport wraps one
+// MessageChannel to the Eddie service worker (widget/src/eddie-sw.js). Both
+// expose the same surface so the widget does not care which one it holds:
+//
+//   call(type, payload, opts?) -> Promise of the reply carrying the requestId
+//   on(type, handler)          -> unsubscribe fn (unsolicited messages: status,
+//                                 ready, progress, token, done, aborted, error,
+//                                 reset, crash)
+//   postRaw(message)              fire-and-forget (abort, ask)
+//   nextId()                      request id for postRaw flows
+//   terminate()
+//
+// The pure decision helpers at the bottom (transport kind, keepalive, state
+// reuse) are what the node tests cover.
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  const HELLO_TIMEOUT_MS = 3000;
+  // Liveness checks must tolerate a busy worker: model loading blocks its
+  // thread for seconds at a time (ONNX session creation, safetensors parsing).
+  const PING_TIMEOUT_MS = 10000;
+  const IDLE_PING_TIMEOUT_MS = 2000;
+  const RECONNECT_HELLO_TIMEOUT_MS = 10000;
+  const KEEPALIVE_MS = 15000;
+  const REGISTER_TIMEOUT_MS = 20000;
+
+  class Emitter {
+    constructor() {
+      this.handlers = new Map();
+    }
+    on(type, handler) {
+      if (!this.handlers.has(type)) this.handlers.set(type, new Set());
+      this.handlers.get(type).add(handler);
+      return () => this.off(type, handler);
+    }
+    off(type, handler) {
+      const set = this.handlers.get(type);
+      if (set) set.delete(handler);
+    }
+    emit(type, msg) {
+      const set = this.handlers.get(type);
+      if (!set) return false;
+      for (const h of Array.from(set)) {
+        try {
+          h(msg);
+        } catch (err) {
+          console.warn("eddie transport handler failed", err);
+        }
+      }
+      return set.size > 0;
+    }
+  }
+
+  function replyError(msg) {
+    const err = new Error(msg.message || "request failed");
+    err.fatal = !!msg.fatal;
+    err.unsupported = !!msg.unsupported;
+    return err;
+  }
+
+  /** Request/reply bookkeeping shared by both transports. */
+  class BaseTransport extends Emitter {
+    constructor(env) {
+      super();
+      this.env = env || {};
+      this.pending = new Map(); // requestId -> { resolve, reject, timer }
+      this.seq = 0;
+      this.closed = false;
+    }
+    /** Ids for the transport's own requests (hello, ping, state); the widget numbers its own. */
+    nextId() {
+      return "t" + ++this.seq;
+    }
+    call(type, payload, opts) {
+      const o = opts || {};
+      return new Promise((resolve, reject) => {
+        if (this.closed) {
+          reject(new Error("transport closed"));
+          return;
+        }
+        const requestId = o.requestId != null ? o.requestId : this.nextId();
+        const entry = { resolve, reject, timer: null };
+        if (o.timeoutMs) {
+          const st = this.env.setTimeout || setTimeout;
+          entry.timer = st(() => {
+            if (this.pending.get(requestId) !== entry) return;
+            this.pending.delete(requestId);
+            const err = new Error(`${type}: no reply within ${o.timeoutMs} ms`);
+            err.timeout = true;
+            reject(err);
+          }, o.timeoutMs);
+        }
+        this.pending.set(requestId, entry);
+        try {
+          this.postRaw(Object.assign({ type, requestId }, payload || {}));
+        } catch (err) {
+          this.pending.delete(requestId);
+          reject(err);
+        }
+      });
+    }
+    failAllPending(err) {
+      const entries = Array.from(this.pending.values());
+      this.pending.clear();
+      for (const p of entries) {
+        if (p.timer) (this.env.clearTimeout || clearTimeout)(p.timer);
+        p.reject(err);
+      }
+    }
+    handleMessage(msg) {
+      const m = msg || {};
+      if (m.requestId != null && this.pending.has(m.requestId)) {
+        const p = this.pending.get(m.requestId);
+        // Streaming replies (token) share the requestId with the final
+        // `done`; only terminal messages settle the promise.
+        if (m.type === "token" || m.type === "progress") {
+          this.emit(m.type, m);
+          return;
+        }
+        this.pending.delete(m.requestId);
+        if (p.timer) (this.env.clearTimeout || clearTimeout)(p.timer);
+        if (m.type === "error") {
+          p.reject(replyError(m));
+          if (m.fatal) this.emit("error", m);
+        } else {
+          p.resolve(m);
+        }
+        return;
+      }
+      this.emit(m.type, m);
+    }
+  }
+
+  /** A dedicated Worker (classic or module). */
+  class DedicatedWorkerTransport extends BaseTransport {
+    constructor(url, opts) {
+      super(opts && opts.env);
+      const o = opts || {};
+      const WorkerCtor = o.Worker || globalThis.Worker;
+      this.kind = "worker";
+      this.worker = o.type ? new WorkerCtor(url, { type: o.type }) : new WorkerCtor(url);
+      this.worker.onmessage = (e) => this.handleMessage(e.data || {});
+      this.worker.onerror = (e) => {
+        const message = e && e.message ? e.message : "worker failed to load";
+        const err = new Error(message);
+        this.failAllPending(err);
+        this.emit("crash", { type: "crash", message });
+      };
+    }
+    get persistent() {
+      return false;
+    }
+    postRaw(msg) {
+      this.worker.postMessage(msg);
+    }
+    ping() {
+      return Promise.resolve({ type: "pong" });
+    }
+    setKeepalive() {
+      // a dedicated worker lives as long as the page
+    }
+    terminate() {
+      this.closed = true;
+      this.failAllPending(new Error("worker terminated"));
+      this.worker.terminate();
+    }
+  }
+
+  /**
+   * One MessageChannel to the Eddie service worker. `connect()` transfers a
+   * port with a `connect` message and waits for `hello`; the keepalive pings
+   * catch a service worker Chrome stopped while idle (ports die with it) and
+   * reconnect, emitting `reset` so the widget re-runs its init flow.
+   */
+  class ServiceWorkerTransport extends BaseTransport {
+    constructor(registration, opts) {
+      super(opts && opts.env);
+      const o = opts || {};
+      this.kind = "sw";
+      this.registration = registration;
+      this.channelKind = o.kind || "search";
+      this.version = o.version || null;
+      this.helloTimeoutMs = o.helloTimeoutMs || HELLO_TIMEOUT_MS;
+      this.pingTimeoutMs = o.pingTimeoutMs || PING_TIMEOUT_MS;
+      this.keepaliveMs = o.keepaliveMs || KEEPALIVE_MS;
+      this.MessageChannel = o.MessageChannel || globalThis.MessageChannel;
+      this.port = null;
+      this.hello = null;
+      this.keepaliveTimer = null;
+      this.reconnecting = null;
+    }
+    get persistent() {
+      return true;
+    }
+    activeWorker() {
+      const r = this.registration;
+      return r.active || r.waiting || r.installing || null;
+    }
+    async connect() {
+      const sw = this.activeWorker();
+      if (!sw) throw new Error("service worker not active");
+      if (this.port) {
+        try {
+          this.port.close();
+        } catch (_) {
+          // ignore
+        }
+      }
+      const ch = new this.MessageChannel();
+      ch.port1.onmessage = (e) => this.handleMessage(e.data || {});
+      this.port = ch.port1;
+      sw.postMessage({ type: "connect", kind: this.channelKind, version: this.version }, [ch.port2]);
+      this.hello = await this.call("hello", {}, { timeoutMs: this.helloTimeoutMs });
+      return this.hello;
+    }
+    postRaw(msg) {
+      if (!this.port) throw new Error("service worker transport not connected");
+      this.port.postMessage(msg);
+    }
+    ping(timeoutMs) {
+      return this.call("ping", {}, { timeoutMs: timeoutMs || this.pingTimeoutMs });
+    }
+    state() {
+      return this.call("state", {}, { timeoutMs: this.pingTimeoutMs });
+    }
+    /** Re-establish the channel after the service worker was stopped. */
+    reconnect() {
+      if (this.reconnecting) return this.reconnecting;
+      this.reconnecting = (async () => {
+        this.failAllPending(new Error("service worker restarted"));
+        const saved = this.helloTimeoutMs;
+        this.helloTimeoutMs = Math.max(saved, RECONNECT_HELLO_TIMEOUT_MS);
+        let hello;
+        try {
+          hello = await this.connect();
+        } finally {
+          this.helloTimeoutMs = saved;
+        }
+        this.emit("reset", { type: "reset", hello });
+        return hello;
+      })().finally(() => {
+        this.reconnecting = null;
+      });
+      return this.reconnecting;
+    }
+    /**
+     * Ping; on silence reconnect. Resolves true when the channel is usable.
+     * `timeoutMs` may be short when the worker is known to be idle (a live
+     * idle worker answers within milliseconds; a stopped one never does),
+     * and must be generous while it may be loading a model.
+     */
+    async ensureAlive(timeoutMs) {
+      try {
+        await this.ping(timeoutMs);
+        return true;
+      } catch (err) {
+        if (this.closed) return false;
+        console.debug(`eddie: ${this.channelKind} channel silent (${err && err.message}); reconnecting`);
+        try {
+          await this.reconnect();
+          console.debug(`eddie: ${this.channelKind} channel reconnected`);
+          return true;
+        } catch (err2) {
+          console.warn("eddie: service worker reconnect failed", err2);
+          this.emit("crash", { type: "crash", message: err2 && err2.message ? err2.message : String(err2) });
+          return false;
+        }
+      }
+    }
+    /**
+     * Keepalive pings are fire-and-forget: their only job is to keep Chrome
+     * from stopping the worker as idle. Liveness is checked explicitly
+     * (ensureAlive) at the points where a dead worker would otherwise hang
+     * the widget, so a worker that is merely busy is never mistaken for a
+     * stopped one.
+     */
+    setKeepalive(wanted) {
+      const si = this.env.setInterval || setInterval;
+      const ci = this.env.clearInterval || clearInterval;
+      if (wanted && !this.keepaliveTimer) {
+        this.keepaliveTimer = si(() => {
+          try {
+            this.postRaw({ type: "ping", requestId: this.nextId() });
+          } catch (_) {
+            // not connected; ensureAlive will deal with it
+          }
+        }, this.keepaliveMs);
+      } else if (!wanted && this.keepaliveTimer) {
+        ci(this.keepaliveTimer);
+        this.keepaliveTimer = null;
+      }
+    }
+    terminate() {
+      this.closed = true;
+      this.setKeepalive(false);
+      this.failAllPending(new Error("transport closed"));
+      if (this.port) {
+        try {
+          this.port.close();
+        } catch (_) {
+          // ignore
+        }
+        this.port = null;
+      }
+    }
+  }
+
+  /**
+   * Register the Eddie service worker and wait until a worker is active.
+   * Never use `navigator.serviceWorker.ready` here: it only resolves for the
+   * registration controlling the *page*, and pages live outside the asset
+   * directory that scopes this worker.
+   */
+  function registerServiceWorker(opts) {
+    const o = opts || {};
+    const container = o.container;
+    const st = o.setTimeout || setTimeout;
+    const ct = o.clearTimeout || clearTimeout;
+    return new Promise((resolve, reject) => {
+      let done = false;
+      const timer = st(() => {
+        if (done) return;
+        done = true;
+        reject(new Error("service worker registration timed out"));
+      }, o.timeoutMs || REGISTER_TIMEOUT_MS);
+      const finish = (fn) => {
+        if (done) return;
+        done = true;
+        ct(timer);
+        fn();
+      };
+      Promise.resolve()
+        .then(() => container.register(o.url, { type: "module", scope: o.scope, updateViaCache: "none" }))
+        .then((registration) => {
+          // A container that resolves register() with nothing at all: some
+          // privacy modes and test harnesses do this rather than rejecting.
+          // Treated as a plain registration failure, so the caller falls
+          // back to page workers with a message that says so.
+          if (!registration) {
+            finish(() => reject(new Error("service worker registration was refused")));
+            return;
+          }
+          if (registration.active) {
+            finish(() => resolve(registration));
+            return;
+          }
+          const sw = registration.installing || registration.waiting;
+          if (!sw) {
+            finish(() => reject(new Error("service worker registration has no worker")));
+            return;
+          }
+          const onChange = () => {
+            if (sw.state === "activated") {
+              sw.removeEventListener("statechange", onChange);
+              finish(() => resolve(registration));
+            } else if (sw.state === "redundant") {
+              sw.removeEventListener("statechange", onChange);
+              finish(() => reject(new Error("service worker became redundant during install")));
+            }
+          };
+          sw.addEventListener("statechange", onChange);
+          onChange();
+        })
+        .catch((err) => finish(() => reject(err)));
+    });
+  }
+
+  // -- pure decisions -----------------------------------------------------
+
+  /**
+   * "sw" when persistence is on and the browser can host it, else "worker".
+   * Service workers need a secure context (localhost counts).
+   */
+  function chooseTransportKind(opts) {
+    const o = opts || {};
+    if (o.persist === "off") return "worker";
+    if (!o.hasServiceWorker) return "worker";
+    if (o.secureContext === false) return "worker";
+    return "sw";
+  }
+
+  /** Keep the service worker alive while the visitor is using it. */
+  function keepaliveWanted(opts) {
+    const o = opts || {};
+    return !!(o.open || o.streaming || o.pending);
+  }
+
+  /** The service worker already holds the model this page would load. */
+  function canReuseAgent(state, modelId) {
+    return !!(state && state.loaded && modelId && state.model === modelId);
+  }
+
+  /** The service worker already holds a ready engine for this exact index URL. */
+  function canReuseSearch(state, indexUrl) {
+    return !!(state && state.phase === "ready" && state.indexLoaded && indexUrl && state.indexUrl === indexUrl);
+  }
+
+  /**
+   * Whether search should stay in a page-side worker even though a service
+   * worker is available: the service worker cannot run webgpu-onnx lanes
+   * (`swOnnx` false, no WebGPU in its scope) while this page has an adapter
+   * and the site allows the WebGPU runtime. Persistence is not worth a
+   * quieter dense lane. Only the gpu tier can run those lanes at all; the
+   * lite and dense tiers never hold a webgpu lane, so the question does not
+   * arise for them.
+   */
+  function searchStaysOnPage(opts) {
+    const o = opts || {};
+    if (o.tier && o.tier !== "gpu") return false;
+    if (o.swOnnx) return false;
+    if (!o.pageHasGpu) return false;
+    return o.denseRuntime !== "wasm";
+  }
+
+  // -- service worker tiers ------------------------------------------------
+  //
+  // Four builds of widget/src/eddie-sw.js (see widget/build.sh), each in
+  // its own scope under the asset directory, so a page installs only the
+  // imports its visitor has opted into:
+  //   lite   eddie-sw-lite.js   keyword + sparse search (lite wasm)
+  //   dense  eddie-sw-dense.js  + the CPU dense lane (dense wasm)
+  //   gpu    eddie-sw-gpu.js    + transformers.js (WebGPU search lane)
+  //   agent  eddie-sw-agent.js  WebLLM + the agent engine, registered at
+  //                             agent consent; never a search host
+
+  // The search tiers. The agent tier is separate: no index lane maps to it
+  // and it is never remembered as a search tier.
+  const SW_TIERS = ["lite", "dense", "gpu"];
+
+  function swScriptName(tier) {
+    return `eddie-sw-${tier}.js`;
+  }
+
+  /** Registration scope of a tier: `<asset dir>sw/<tier>/` (a key, never navigated to). */
+  function swScope(baseUrl, tier) {
+    return String(baseUrl).replace(/\/?$/, "/") + "sw/" + tier + "/";
+  }
+
+  /** The tier that can host a dense lane of `kind` ("wasm-candle" | "webgpu-onnx" | null). */
+  function tierForLane(kind) {
+    if (kind === "webgpu-onnx") return "gpu";
+    if (kind === "wasm-candle") return "dense";
+    return "lite";
+  }
+
+  /**
+   * Which tier the search engine should live in right now: the tier of the
+   * lane about to be loaded (`laneKind`, known once the engine asked for
+   * consent or the visitor accepted), else the tier remembered from an
+   * earlier consent on this browser (`rememberedTier`), else lite.
+   */
+  function searchTierFor(opts) {
+    const o = opts || {};
+    if (o.laneKind) return tierForLane(o.laneKind);
+    if (SW_TIERS.includes(o.rememberedTier)) return o.rememberedTier;
+    return "lite";
+  }
+
+  /**
+   * Eddie 0.4.2 registered one service worker with scope = the asset
+   * directory. Its script (eddie-sw.js) no longer ships; unregister it so
+   * the browser stops trying to update it. Any other registration matching
+   * that URL (the site's own worker at "/") is left alone.
+   */
+  async function unregisterLegacyServiceWorker(container, baseUrl) {
+    if (!container || typeof container.getRegistration !== "function") return false;
+    let reg;
+    try {
+      reg = await container.getRegistration(baseUrl);
+    } catch (_) {
+      return false;
+    }
+    if (!reg || reg.scope !== baseUrl) return false;
+    try {
+      await reg.unregister();
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  return {
+    SW_TIERS,
+    swScriptName,
+    swScope,
+    tierForLane,
+    searchTierFor,
+    unregisterLegacyServiceWorker,
+    HELLO_TIMEOUT_MS,
+    PING_TIMEOUT_MS,
+    IDLE_PING_TIMEOUT_MS,
+    KEEPALIVE_MS,
+    Emitter,
+    BaseTransport,
+    DedicatedWorkerTransport,
+    ServiceWorkerTransport,
+    registerServiceWorker,
+    chooseTransportKind,
+    keepaliveWanted,
+    canReuseAgent,
+    canReuseSearch,
+    searchStaysOnPage,
+  };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
+// Warm-at-load decision (`data-warm`): whether the widget should initialise
+// the search engine before the visitor opens the modal. Pure; the widget
+// supplies what it knows and acts on the returned action.
+
+(function (factory) {
+  const api = factory();
+  if (typeof module === "object" && module && module.exports) {
+    module.exports = api;
+  } else if (typeof EddieLib === "object" && EddieLib) {
+    Object.assign(EddieLib, api);
+  } else {
+    globalThis.EddieLib = Object.assign(globalThis.EddieLib || {}, api);
+  }
+})(function () {
+  "use strict";
+
+  const SEARCH_CONSENT_KEY = "eddie.search.consent";
+  // The service worker tier that consent needs ("dense" | "gpu"), so a
+  // returning visitor's warm-up registers the right worker at once.
+  const SEARCH_TIER_KEY = "eddie.search.tier";
+  // Set on the first modal open: from then on the visitor is "returning".
+  const SEARCH_USED_KEY = "eddie.search.used";
+
+  /**
+   * opts:
+   *   mode          "auto" | "off" | "always"
+   *   saveData      navigator.connection.saveData
+   *   returning     the visitor opened the search or accepted a model on this
+   *                 browser before (localStorage); a first-time visitor never
+   *                 warms in "auto", so a plain page view registers nothing
+   *   engineReady   a persistent engine already reports `ready` for this index
+   *   checked       a cache_check result is in (lane/cached below are valid)
+   *   lane          the dense lane the engine would load ({id} or null)
+   *   cached        that lane's files are in IndexedDB
+   *   consentedLane lane id from localStorage (the visitor accepted it before)
+   *
+   * Returns { action: "none" | "adopt" | "check" | "init", consent, reason }.
+   *   adopt: take over the ready engine, no init needed
+   *   check: run cache_check (site assets only), then call again with the result
+   *   init : send init; `consent` says whether to pass consent=true
+   */
+  function decideWarm(opts) {
+    const o = opts || {};
+    const mode = o.mode || "auto";
+    if (mode === "off") return { action: "none", consent: false, reason: "warm is off" };
+    if (o.engineReady) return { action: "adopt", consent: false, reason: "engine already ready" };
+    if (!o.checked) {
+      if (mode === "auto" && o.saveData) return { action: "none", consent: false, reason: "data saver" };
+      if (mode === "auto" && !o.returning) return { action: "none", consent: false, reason: "first visit" };
+      return { action: "check", consent: false, reason: "cache state unknown" };
+    }
+    if (!o.lane) return { action: "init", consent: false, reason: "no dense lane to download" };
+    if (o.cached) {
+      if (mode === "always") return { action: "init", consent: false, reason: "lane cached (always)" };
+      if (o.consentedLane && o.consentedLane === o.lane.id) return { action: "init", consent: false, reason: "lane cached and consented before" };
+      return { action: "none", consent: false, reason: "lane cached but never consented on this browser" };
+    }
+    if (mode === "always") {
+      if (o.saveData) return { action: "none", consent: false, reason: "data saver" };
+      return { action: "init", consent: true, reason: "always warms uncached lanes" };
+    }
+    return { action: "none", consent: false, reason: "lane not cached" };
+  }
+
+  return { SEARCH_CONSENT_KEY, SEARCH_TIER_KEY, SEARCH_USED_KEY, decideWarm };
+});
+
+// SPDX-License-Identifier: GPL-3.0-only
+
 // Eddie search widget
 //
 // Self-contained vanilla JS widget in a closed Shadow DOM. Talks to the
-// search worker (eddie-worker.js) for retrieval and, on demand, to the agent
-// worker (eddie-agent-worker.js) for a streamed, cited answer.
+// search engine for retrieval and, on demand, to the agent for a streamed,
+// cited answer. Both engines live either in the Eddie service worker
+// (eddie-sw.js, persistent across navigations; see "Persistent engines" in
+// widget/README.md) or, as the fallback, in page-side workers
+// (eddie-worker.js, eddie-agent-worker.js). The transports in lib/transport.js
+// hide the difference.
 //
 // widget/build.sh concatenates widget/src/lib/*.js ahead of this file inside
 // one IIFE, so the pure helpers are available as `EddieLib` without leaking a
@@ -706,9 +1299,23 @@ const EddieLib = {};
 (function () {
   const scriptEl = document.currentScript;
   if (!scriptEl) return;
+  // Loaded twice (a page that carries eddie-boot.js and eddie-widget.js, or
+  // a second injection): the first mount wins.
+  if (document.getElementById("eddie-host")) return;
   const lib = EddieLib;
 
-  const config = lib.parseWidgetConfig((name) => scriptEl.getAttribute(name));
+  // The site's data-* config is the ceiling; the visitor's stored
+  // preferences (gear menu) are applied on top of it. The lane list and the
+  // WebGPU probe are not available yet, so this first pass only enforces the
+  // ceiling -- the panel corrects any stale preference once the engine
+  // reports what the index actually offers.
+  const siteConfig = lib.parseWidgetConfig((name) => scriptEl.getAttribute(name));
+  let settings = lib.readSettings(localStore());
+  let config = lib.effectiveConfig(
+    siteConfig,
+    settings,
+    lib.settingsChoices({ config: siteConfig, lanes: null })
+  );
   const scriptHref = new URL(scriptEl.src, location.href).href;
   const baseUrl = lib.baseUrlOf(scriptHref);
   const indexUrl = config.indexUrl
@@ -718,6 +1325,8 @@ const EddieLib = {};
   const siteName = config.qaSubject || location.hostname;
   const reducedMotion = !!(window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches);
   const saveData = !!(navigator.connection && navigator.connection.saveData);
+  // Read once, before any open on this page marks the visitor as returning.
+  const returningAtLoad = !!(readSearchConsent() || searchUsedBefore());
 
   const HEART_SPRITES = [
     [".11111.", "1222221", "1222221", ".12221."], // solid
@@ -728,27 +1337,59 @@ const EddieLib = {};
   const HEART_PALETTE = { 1: "#f2c94c", 2: "#e0b63f", 3: "#f8dda1", 4: "#b78e28" };
   const HIDDEN_SECTIONS = /^(summary|summary lane|semantic segment)$/i;
   const AGENT_CONSENT_KEY = "eddie.agent.consent";
+  const SEARCH_CONSENT_KEY = lib.SEARCH_CONSENT_KEY;
+  const SEARCH_TIER_KEY = lib.SEARCH_TIER_KEY;
+  const SEARCH_USED_KEY = lib.SEARCH_USED_KEY;
+  // How long a modal open waits for the transport decision (service worker
+  // registration + hello) before starting a page-side worker instead.
+  const TRANSPORT_WAIT_MS = 3000;
+  // Longest a search-engine request may stay unanswered over the service
+  // worker before the widget checks whether the worker is still alive.
+  const SW_CALL_TIMEOUT_MS = 60000;
+
+  /** `localStorage`, or null where reading it throws (some privacy modes). */
+  function localStore() {
+    try {
+      return window.localStorage;
+    } catch (_) {
+      return null;
+    }
+  }
 
   // -- State --
-  let worker = null;
+  let laneInfo = null; // { lanes, hostSkipped } once the engine has read the index
+  let settingsOpen = false;
+  let search = null; // search transport (lib/transport.js), null until needed
   let workerState = "idle"; // idle | loading | index_ready | awaiting_consent | ready | error | dead
   let searchable = false;
+  let initSent = false; // an init went to the current search transport
   let requestSeq = 0;
-  const pending = new Map(); // requestId -> { resolve, reject }
   let activeSearchId = 0;
   let isOpen = false;
   let selectedIndex = -1;
   let currentResults = [];
   let lastHeartIndex = -1;
   let consentDeclined = false;
+  let pendingConsentLane = null; // lane id of the consent card being shown
   let lastDegradedNotice = null;
   let lastAnnouncedQuarter = -1;
   let manifestInfo = null;
   let searchTimer = null;
   let lastSearchedQuery = "";
+  let initWaiters = []; // resolve() once the index is loaded (index_ready or ready)
+  const transportPlans = Object.create(null); // tier -> Promise<{kind, registration?, hello?, sw?}>
+  let searchTier = null; // "lite" | "dense" | "gpu": the tier the search transport was made for
+  let pendingConsentKind = null; // runtime kind of the lane the consent card is for
+  let searchCreating = null; // Promise while ensureSearchTransport runs
+  let switching = null; // Promise while the search moves to another tier
+  let legacyCleanup = null; // Promise: the 0.4.2 single-scope registration, unregistered once
+  let forcePageWorkers = false; // after a dead service-worker engine: this page uses page workers
+  let pageGpu = null; // null (unknown) | false | { maxBufferSize, hasF16 }
+  let pageGpuProbe = null;
 
   let agentInfo = null; // null (unknown) | false | { maxBufferSize, hasF16 }
-  let agentWorker = null;
+  let agent = null; // agent transport, null until the first Ask
+  let agentCreating = null;
   let agentModel = null; // { id, base, sizeBytes }
   let agentLoaded = false;
   let agentLoading = null; // Promise while a load is in flight
@@ -936,7 +1577,25 @@ const EddieLib = {};
       line-height: 1;
       transition: border-color 0.1s;
     }
-    .sa-close:hover { border-color: var(--sa-text-muted); }
+    .sa-close:hover { border-color: var(--sa-text-muted); }
+    .sa-gear svg { width: 15px; height: 15px; display: block; }
+    .sa-gear[aria-expanded="true"] { border-color: var(--sa-accent); color: var(--sa-accent); }
+
+    .sa-set-body { display: flex; flex-direction: column; gap: 12px; }
+    .sa-set-group { display: flex; flex-direction: column; gap: 4px; }
+    .sa-set-group > .sa-set-legend {
+      font-size: 11px;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      color: var(--sa-text-muted);
+      font-family: var(--sa-font-mono);
+    }
+    .sa-set-opt { display: flex; align-items: baseline; gap: 8px; cursor: pointer; padding: 2px 0; }
+    .sa-set-opt input { margin: 0; flex-shrink: 0; accent-color: var(--sa-accent); }
+    .sa-set-opt-main { font-size: 13px; }
+    .sa-set-opt-detail { font-size: 12px; color: var(--sa-text-muted); }
+    .sa-set-note { font-size: 12px; color: var(--sa-text-muted); }
+    .sa-set-storage { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; font-size: 13px; }
 
     .sa-heart { flex-shrink: 0; width: 14px; height: 8px; image-rendering: pixelated; image-rendering: crisp-edges; opacity: 0.95; display: block; }
 
@@ -1174,6 +1833,14 @@ const EddieLib = {};
   askBtn.hidden = true;
   header.appendChild(askBtn);
 
+  const gearBtn = button("sa-close sa-gear", "", toggleSettings, {
+    "aria-label": "Settings",
+    "aria-expanded": "false",
+    title: "Settings",
+  });
+  gearBtn.appendChild(createGearSvg());
+  header.appendChild(gearBtn);
+
   const closeBtn = button("sa-close", "esc", closeModal, { "aria-label": "Close (Esc)" });
   header.appendChild(closeBtn);
 
@@ -1219,6 +1886,22 @@ const EddieLib = {};
   consentCard.appendChild(consentActions);
   modal.appendChild(consentCard);
 
+  // Settings panel (gear): visitor preferences over the site's data-* config.
+  const settingsCard = el("div", "sa-card sa-settings");
+  settingsCard.setAttribute("role", "group");
+  settingsCard.setAttribute("aria-label", "Search settings");
+  const settingsLabel = el("div", "sa-card-label", "Settings");
+  const settingsBody = el("div", "sa-set-body");
+  const settingsActions = el("div", "sa-card-actions");
+  const settingsReset = button("sa-btn", "Use this site's defaults", resetSettings);
+  const settingsDone = button("sa-btn sa-btn-primary", "Done", () => setSettingsOpen(false));
+  settingsActions.appendChild(settingsDone);
+  settingsActions.appendChild(settingsReset);
+  settingsCard.appendChild(settingsLabel);
+  settingsCard.appendChild(settingsBody);
+  settingsCard.appendChild(settingsActions);
+  modal.appendChild(settingsCard);
+
   // Error area
   const errorEl = el("div", "sa-error");
   errorEl.setAttribute("role", "alert");
@@ -1353,7 +2036,9 @@ const EddieLib = {};
   modal.addEventListener("keydown", (e) => {
     if (e.key === "Escape") {
       e.preventDefault();
-      closeModal();
+      // Esc backs out of the settings panel first, then closes the modal.
+      if (settingsOpen) setSettingsOpen(false);
+      else closeModal();
       return;
     }
     if (e.key !== "Tab") return;
@@ -1383,50 +2068,315 @@ const EddieLib = {};
     return true;
   }
 
-  // -- Search worker --
-  function ensureWorker() {
-    if (worker) {
-      if (workerState === "error") retryInit();
-      return;
-    }
+  // -- Transports --
+  // The decision (service worker or page workers) starts after `load`, from
+  // an idle callback, so registration never delays the page. Modal opens
+  // wait for it at most TRANSPORT_WAIT_MS; warm-up waits as long as it takes.
+  function onIdle(fn) {
+    if (typeof requestIdleCallback === "function") requestIdleCallback(() => fn(), { timeout: 2000 });
+    else setTimeout(fn, 200);
+  }
+
+  function afterLoad(fn) {
+    if (document.readyState === "complete") fn();
+    else window.addEventListener("load", () => fn(), { once: true });
+  }
+
+  /**
+   * The transport decision for one service worker tier (see
+   * lib/transport.js): register that tier's worker and say hello, or fall
+   * back to page workers. Made once per tier and only when something needs
+   * it: a modal open (lite), a consent (dense/gpu), an Ask (agent) or a
+   * returning visitor's warm-up. A plain page view registers nothing.
+   */
+  function ensureTransportPlan(tier) {
+    const t = tier || "lite";
+    if (!transportPlans[t]) transportPlans[t] = setupTransport(t);
+    return transportPlans[t];
+  }
+
+  async function setupTransport(tier) {
+    const kind = lib.chooseTransportKind({
+      persist: config.persist,
+      hasServiceWorker: !!navigator.serviceWorker,
+      secureContext: window.isSecureContext,
+    });
+    if (kind !== "sw" || forcePageWorkers) return { kind: "worker", tier };
+    // The agent tier's channel speaks the agent protocol; every other tier
+    // hosts the search engine.
+    const channelKind = tier === "agent" ? "agent" : "search";
+    let registration = null;
+    let sw = null;
     try {
-      worker = new Worker(lib.assetUrl(baseUrl, "eddie-worker.js", version));
+      if (!legacyCleanup) {
+        legacyCleanup = lib.unregisterLegacyServiceWorker(navigator.serviceWorker, baseUrl).then((done) => {
+          if (done) console.info("eddie: unregistered the 0.4.2 service worker (scope " + baseUrl + ")");
+        });
+      }
+      await legacyCleanup;
+      registration = await lib.registerServiceWorker({
+        container: navigator.serviceWorker,
+        url: lib.assetUrl(baseUrl, lib.swScriptName(tier), lib.ASSET_VERSION),
+        scope: lib.swScope(baseUrl, tier),
+      });
+      sw = new lib.ServiceWorkerTransport(registration, { kind: channelKind, version });
+      const hello = await sw.connect();
+      if (hello.tier && hello.tier !== tier) throw new Error(`service worker at ${lib.swScope(baseUrl, tier)} reports tier ${hello.tier}`);
+      // The gpu tier cannot run a webgpu-onnx lane without WebGPU in the
+      // service worker's scope while this page could: search stays
+      // page-side for quality, the agent still goes wherever the service
+      // worker can host it.
+      if (channelKind === "search" && lib.searchStaysOnPage({ tier, swOnnx: hello.onnx, pageHasGpu: !!(await probePageGpu()), denseRuntime: config.denseRuntime })) {
+        sw.terminate();
+        sw = null;
+      }
+      return { kind: "sw", tier, registration, hello, sw };
     } catch (err) {
-      showInitError("Couldn't start the search worker: " + (err && err.message ? err.message : err), false);
-      return;
+      console.info(`eddie: ${tier} service worker unavailable, using page workers:`, err && err.message ? err.message : err);
+      if (sw) sw.terminate();
+      return { kind: "worker", tier };
+    }
+  }
+
+  function withDeadline(promise, ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), ms);
+      promise.then(
+        (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        () => {
+          clearTimeout(timer);
+          resolve(null);
+        }
+      );
+    });
+  }
+
+  function probePageGpu() {
+    if (pageGpu !== null) return Promise.resolve(pageGpu);
+    if (pageGpuProbe) return pageGpuProbe;
+    pageGpuProbe = (async () => {
+      pageGpu = false;
+      if (!navigator.gpu || typeof navigator.gpu.requestAdapter !== "function") return pageGpu;
+      try {
+        const adapter = await navigator.gpu.requestAdapter();
+        if (adapter) {
+          pageGpu = {
+            maxBufferSize: adapter.limits ? adapter.limits.maxBufferSize : 0,
+            hasF16: !!(adapter.features && adapter.features.has("shader-f16")),
+          };
+        }
+      } catch (err) {
+        console.warn("eddie: WebGPU adapter probe failed", err);
+      }
+      return pageGpu;
+    })();
+    return pageGpuProbe;
+  }
+
+  // -- Search transport --
+  /**
+   * Create and wire the search transport for `tier` (no init yet). `waitMs`
+   * bounds the transport decision; the tier defaults to the one a stored
+   * consent remembers, else lite.
+   */
+  function ensureSearchTransport(waitMs, tier) {
+    if (search) return Promise.resolve(search);
+    if (searchCreating) return searchCreating;
+    const t0 = tier || lib.searchTierFor({ rememberedTier: readSearchTier() });
+    searchCreating = (async () => {
+      const t = await createSearchTransport(t0, waitMs);
+      if (search) return search;
+      if (!t) return null;
+      attachSearch(t.transport, t.plan, t0);
+      return t.transport;
+    })().finally(() => {
+      searchCreating = null;
+    });
+    return searchCreating;
+  }
+
+  /** A transport for `tier`: the tier's service worker channel, else a page worker. */
+  async function createSearchTransport(tier, waitMs) {
+    const planPromise = ensureTransportPlan(tier);
+    const plan = waitMs == null ? await planPromise.catch(() => null) : await withDeadline(planPromise, waitMs);
+    let t = plan && plan.kind === "sw" && plan.sw && !forcePageWorkers ? plan.sw : null;
+    if (t && t.closed) t = null;
+    if (!t) {
+      try {
+        t = new lib.DedicatedWorkerTransport(lib.assetUrl(baseUrl, "eddie-worker.js", lib.ASSET_VERSION));
+      } catch (err) {
+        showInitError("Couldn't start the search worker: " + (err && err.message ? err.message : err), false);
+        return null;
+      }
     }
-    worker.onmessage = (e) => onWorkerMessage(e.data || {});
-    worker.onerror = (e) => {
+    return { transport: t, plan };
+  }
+
+  /**
+   * Move the search engine to the tier that can host the lane the visitor
+   * just accepted (a lite service worker has no candle, no transformers.js).
+   * Page workers load what they need themselves and never move. The old
+   * channel is dropped; Chrome stops the idle worker on its own.
+   */
+  function switchSearchTier(tier) {
+    if (!search || search.kind !== "sw" || tier === searchTier) return Promise.resolve();
+    if (switching) return switching;
+    switching = (async () => {
+      const made = await createSearchTransport(tier, null);
+      if (!made || !search) return;
+      const old = search;
+      try {
+        old.postRaw({ type: "disconnect" });
+      } catch (_) {
+        // port already gone
+      }
+      old.terminate();
+      search = null;
+      searchable = false;
+      initSent = false;
+      setWorkerState("idle");
+      attachSearch(made.transport, made.plan, tier);
+      console.info(`eddie: search moved to the ${tier} tier (${made.transport.kind})`);
+    })().finally(() => {
+      switching = null;
+    });
+    return switching;
+  }
+
+  function attachSearch(t, plan, tier) {
+    search = t;
+    searchTier = tier || "lite";
+    initSent = false;
+    host.dataset.transport = t.kind;
+    host.dataset.tier = searchTier;
+    t.on("status", handleStatus);
+    t.on("ready", handleReady);
+    t.on("error", (msg) => {
+      if (msg.requestId != null) return; // request errors reject their promise
+      if (msg.fatal) onFatal(msg.message);
+      else showInitError(msg.message || "Search failed", false);
+    });
+    t.on("crash", (msg) => {
       // An uncaught error in the worker script (a 404, a syntax error, an
-      // exception outside a handler): start a fresh worker on Retry.
-      const message = e && e.message ? e.message : "search worker failed to load";
+      // exception outside a handler) or a service worker that could not be
+      // reconnected: start afresh on Retry.
       setWorkerState("dead");
       searchable = false;
       showStatus(false);
-      showInitError(message, true);
-      failAllPending(new Error(message));
+      showInitError(msg.message || "search worker failed to load", true);
+      failInitWaiters(new Error(msg.message || "search worker failed"));
+    });
+    t.on("reset", () => {
+      // The service worker was stopped while idle and reconnected: its engine
+      // is empty again. Re-run init transparently when the modal is open;
+      // otherwise the next open does it.
+      console.info("eddie: search engine restarted");
+      searchable = false;
+      initSent = false;
+      setWorkerState("idle");
+      host.dataset.arms = "";
+      host.dataset.lane = "";
+      host.dataset.runtime = "";
+      if (isOpen) postInit(false);
+    });
+    if (t.kind === "sw" && plan && plan.hello && plan.hello.search) {
+      // A worker that already holds the index does not re-post index_ready on
+      // a second init, so its snapshot is where a fresh page learns the lanes.
+      rememberLanes(plan.hello.search);
+      if (lib.canReuseSearch(plan.hello.search, indexUrl) && runsPreferredLane(plan.hello.search)) {
+        adoptReadyState(plan.hello.search);
+      }
+    }
+  }
+
+  /**
+   * Is a ready engine running the lane this visitor asked for? A worker left
+   * over from before a settings change is ready for the right index but the
+   * wrong lane, and adopting it would silently ignore the preference.
+   */
+  function runsPreferredLane(st) {
+    if (config.denseRuntime === "off") return !st.lane;
+    if (config.laneId) return st.lane === config.laneId;
+    return true;
+  }
+
+  /** The service worker already holds a ready engine for this index: mirror it. */
+  function adoptReadyState(st) {
+    initSent = true;
+    handleReady({
+      type: "ready",
+      lanes: st.lanes || [],
+      lane: st.lane,
+      runtime: st.runtime,
+      arms: st.arms || { dense: false, sparse: false, bm25: true },
+      degraded: st.degraded || [],
+      manifest: st.manifest,
+      reused: true,
+    });
+  }
+
+  /** Modal-open path: make sure a transport exists and an init is under way. */
+  async function ensureWorker() {
+    if (search) {
+      if (workerState === "error") {
+        retryInit();
+        return;
+      }
+      // With the modal closed nothing pinged the service worker, so Chrome
+      // may have stopped it: a failed ping reconnects and emits reset,
+      // which re-sends init while the modal is open. A worker that is
+      // streaming load status is alive by definition (and may be too busy
+      // to answer a ping in time).
+      if (search.kind === "sw" && initSent && workerState !== "loading") await search.ensureAlive(lib.IDLE_PING_TIMEOUT_MS);
+      if (search && !initSent) postInit(false);
+      return;
+    }
+    const t = await ensureSearchTransport(TRANSPORT_WAIT_MS);
+    if (!t) return;
+    if (!initSent) postInit(false);
+  }
+
+  /** The "Search model" group is built from this; every engine message that carries a lane list refreshes it. */
+  function rememberLanes(msg) {
+    if (!msg || !Array.isArray(msg.lanes)) return;
+    laneInfo = {
+      lanes: msg.lanes,
+      hostSkipped: Array.isArray(msg.hostSkippedLanes) ? msg.hostSkippedLanes : [],
     };
-    postInit(false);
+    if (settingsOpen) currentChoices().then(renderSettings);
   }
 
   function postInit(consent) {
+    if (!search) return;
+    initSent = true;
     setWorkerState("loading");
     hide(errorEl);
-    worker.postMessage({
+    search.postRaw({
       type: "init",
       indexUrl,
       baseUrl,
       version,
       denseRuntime: config.denseRuntime,
+      laneId: config.laneId || null,
       consent: !!consent,
+      consentLane: consent ? pendingConsentLane : undefined,
     });
+    updateKeepalive();
   }
 
   function retryInit() {
     hide(errorEl);
-    if (!worker || workerState === "dead") {
-      if (worker) worker.terminate();
-      worker = null;
+    if (!search || workerState === "dead") {
+      if (search) {
+        // A dead engine inside the service worker stays dead until Chrome
+        // restarts it; this page continues with page-side workers.
+        if (search.kind === "sw") forcePageWorkers = true;
+        search.terminate();
+      }
+      search = null;
       searchable = false;
       setWorkerState("idle");
       ensureWorker();
@@ -1435,80 +2385,112 @@ const EddieLib = {};
     postInit(false);
   }
 
-  function callWorker(type, payload) {
+  /** Resolves once the index is loaded in the current transport. */
+  function whenIndexLoaded() {
+    if (searchable) return Promise.resolve();
     return new Promise((resolve, reject) => {
-      if (!worker) {
-        reject(new Error("search worker not running"));
-        return;
-      }
-      const requestId = ++requestSeq;
-      pending.set(requestId, { resolve, reject });
-      worker.postMessage(Object.assign({ type, requestId }, payload || {}));
+      initWaiters.push({ resolve, reject });
     });
   }
 
-  function failAllPending(err) {
-    pending.forEach((p) => p.reject(err));
-    pending.clear();
+  function resolveInitWaiters() {
+    const waiters = initWaiters;
+    initWaiters = [];
+    waiters.forEach((w) => w.resolve());
   }
 
-  function onWorkerMessage(msg) {
-    if (msg.requestId != null && pending.has(msg.requestId)) {
-      const p = pending.get(msg.requestId);
-      pending.delete(msg.requestId);
-      if (msg.type === "error") {
-        const err = new Error(msg.message || "request failed");
-        err.fatal = !!msg.fatal;
-        p.reject(err);
-        if (msg.fatal) onFatal(msg.message);
-      } else {
-        p.resolve(msg);
+  function failInitWaiters(err) {
+    const waiters = initWaiters;
+    initWaiters = [];
+    waiters.forEach((w) => w.reject(err));
+  }
+
+  /**
+   * A request to the search engine. A "not initialised" reply (the service
+   * worker restarted, or a page-side worker that never got init) re-runs the
+   * init flow once and retries.
+   */
+  async function callWorker(type, payload) {
+    if (!search) throw new Error("search worker not running");
+    const requestId = ++requestSeq;
+    // A service worker that died mid-request never answers: bound the wait
+    // and let the retry below reconnect.
+    const opts = { requestId, timeoutMs: search.kind === "sw" ? SW_CALL_TIMEOUT_MS : 0 };
+    try {
+      return await search.call(type, payload, opts);
+    } catch (err) {
+      if (!err || err.fatal || !search) throw err;
+      if (err.timeout) {
+        if (!(await search.ensureAlive())) throw err;
+      } else if (!lib.isNotLoadedMessage(err.message) && !/service worker restarted/.test(err.message)) {
+        throw err;
       }
-      return;
-    }
-    switch (msg.type) {
-      case "status":
-        handleStatus(msg);
-        break;
-      case "ready":
-        handleReady(msg);
-        break;
-      case "error":
-        if (msg.fatal) onFatal(msg.message);
-        else showInitError(msg.message || "Search failed", false);
-        break;
-      default:
-        break;
+      if (!search) throw err;
+      if (!initSent || workerState === "idle") postInit(false);
+      await whenIndexLoaded();
+      return search.call(type, payload, { requestId: ++requestSeq, timeoutMs: opts.timeoutMs });
     }
   }
 
+  function updateKeepalive() {
+    const wanted = lib.keepaliveWanted({
+      open: isOpen,
+      streaming: !!(agentRun && !agentRun.done),
+      pending: !!(search && search.pending && search.pending.size > 0),
+    });
+    if (search) search.setKeepalive(wanted);
+    if (agent) agent.setKeepalive(wanted);
+  }
+
   function onFatal(message) {
     setWorkerState("dead");
     searchable = false;
     showStatus(false);
     showInitError(message || "The search engine crashed.", true);
+    failInitWaiters(new Error(message || "search engine crashed"));
   }
 
   function handleStatus(msg) {
     switch (msg.state) {
       case "loading_wasm":
         setWorkerState("loading");
-        setStatus("Loading search engine…", null);
+        setStatus(msg.variant === "dense" ? "Loading the dense search engine…" : "Loading search engine…", null);
         announce("Loading search engine");
         break;
       case "loading_index":
         setStatus("Loading index…", msg.progress);
         break;
+      case "loading_sidecar":
+        setStatus("Loading index vectors…", msg.progress);
+        break;
       case "index_ready":
         manifestInfo = msg.manifest || null;
+        rememberLanes(msg);
         setWorkerState("index_ready");
         searchable = true;
-        setStatus("Loading search model…", null);
+        if (initSent) setStatus("Loading search model…", null);
+        resolveInitWaiters();
         rerunQuery();
         break;
+      case "tier_required":
+        // The engine's host cannot run the lane it chose (lite worker, cached
+        // webgpu lane): move the search to the tier that can and init again.
+        console.info(`eddie: ${msg.message || "tier change"}; moving search to the ${msg.tier} tier`);
+        if (search && search.kind === "sw" && lib.SW_TIERS.includes(msg.tier)) {
+          switchSearchTier(msg.tier).then(() => {
+            if (search && !initSent) postInit(false);
+          });
+        } else {
+          setWorkerState("error");
+          showInitError(msg.message || "This host cannot run the search model", true);
+        }
+        break;
       case "consent_required":
         setWorkerState("awaiting_consent");
+        rememberLanes(msg);
         showStatus(false);
+        pendingConsentLane = msg.lane && msg.lane.id ? msg.lane.id : null;
+        pendingConsentKind = msg.lane && msg.lane.kind ? msg.lane.kind : null;
         if (consentDeclined) break;
         showConsent(msg);
         break;
@@ -1532,6 +2514,7 @@ const EddieLib = {};
         setWorkerState(msg.fatal ? "dead" : "error");
         showStatus(false);
         showInitError(msg.message || "Failed to initialise search", !msg.unsupported);
+        failInitWaiters(new Error(msg.message || "search failed to initialise"));
         break;
       default:
         break;
@@ -1542,15 +2525,130 @@ const EddieLib = {};
     setWorkerState("ready");
     searchable = true;
     manifestInfo = msg.manifest || manifestInfo;
+    rememberLanes(msg);
     const arms = msg.arms || {};
     host.dataset.arms = Object.keys(arms).filter((k) => arms[k]).join(",");
     host.dataset.lane = msg.lane || "";
     host.dataset.runtime = msg.runtime || "";
+    host.dataset.readyMs = String(Math.round(performance.now()));
+    host.dataset.reused = msg.reused ? "true" : "false";
+    host.dataset.wasm = msg.wasm || "";
+    if (msg.lane) rememberSearchConsent(msg.lane, msg.runtime === "webgpu" ? "gpu" : "dense");
     showStatus(false);
     hide(consentCard);
     lastDegradedNotice = lib.degradedNotice(msg.arms, msg.degraded);
     announce(lastDegradedNotice ? "Search ready. " + lastDegradedNotice : "Search ready");
+    resolveInitWaiters();
     rerunQuery();
+    updateKeepalive();
+  }
+
+  // -- Warm at load (data-warm) --
+  // Runs after `load` and an idle callback. In "auto" only a returning
+  // visitor (opened the search or accepted a model on this browser before)
+  // gets a transport at all, and a model download only after a prior
+  // consent with the files still cached; `always` is the site owner's
+  // choice to warm uncached lanes too. A first-time visitor's page view
+  // fetches nothing beyond this script.
+  async function warmUp() {
+    if (config.warm === "off" || search || isOpen) return;
+    const rememberedTier = readSearchTier();
+    let decision = lib.decideWarm({ mode: config.warm, saveData, engineReady: false, checked: false, returning: returningAtLoad });
+    console.debug("eddie warm:", decision.action, decision.reason);
+    if (decision.action === "none") return;
+    const tier = lib.searchTierFor({ rememberedTier });
+    const plan = await ensureTransportPlan(tier).catch(() => null);
+    if (!plan || search || isOpen) return; // the modal opened first: the normal flow owns init
+    const engineReady = plan.kind === "sw" && !!plan.sw && lib.canReuseSearch(plan.hello.search, indexUrl);
+    decision = lib.decideWarm({ mode: config.warm, saveData, engineReady, checked: false, returning: true });
+    console.debug("eddie warm:", decision.action, decision.reason);
+    if (decision.action === "none") return;
+    const t = await ensureSearchTransport(null, tier);
+    if (!t) return;
+    if (decision.action === "adopt") return; // attachSearch adopted the ready state
+    if (initSent || isOpen) return;
+    let cr;
+    try {
+      cr = await search.call("cache_check", { indexUrl, baseUrl, version, denseRuntime: config.denseRuntime }, { requestId: ++requestSeq, timeoutMs: 240000 });
+    } catch (err) {
+      console.info("eddie warm: cache check failed:", err && err.message ? err.message : err);
+      return;
+    }
+    if (initSent || !search) return;
+    decision = lib.decideWarm({
+      mode: config.warm,
+      saveData,
+      engineReady: cr.phase === "ready",
+      checked: true,
+      returning: true,
+      lane: cr.lane,
+      cached: cr.cached,
+      consentedLane: readSearchConsent(),
+    });
+    console.debug("eddie warm:", decision.action, decision.reason);
+    if (decision.action === "init") {
+      if (cr.lane) {
+        pendingConsentLane = cr.lane.id;
+        pendingConsentKind = cr.lane.kind || null;
+        // The engine will load this lane: make sure the transport can host it.
+        await switchSearchTier(lib.searchTierFor({ laneKind: cr.lane.kind }));
+        if (!search) return;
+      }
+      postInit(decision.consent);
+    } else if (decision.action === "adopt") {
+      postInit(false); // the engine answers with ready at once
+    }
+  }
+
+  function readSearchConsent() {
+    try {
+      return localStorage.getItem(SEARCH_CONSENT_KEY) || null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function readSearchTier() {
+    try {
+      return localStorage.getItem(SEARCH_TIER_KEY) || null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function searchUsedBefore() {
+    try {
+      return !!localStorage.getItem(SEARCH_USED_KEY);
+    } catch (_) {
+      return false;
+    }
+  }
+
+  function rememberSearchUsed() {
+    try {
+      localStorage.setItem(SEARCH_USED_KEY, "1");
+    } catch (_) {
+      // storage unavailable: every visit is a first visit
+    }
+  }
+
+  /** The tier the next page should register directly. "lite" is the default, so it clears the key. */
+  function rememberSearchTier(tier) {
+    try {
+      if (tier && tier !== "lite") localStorage.setItem(SEARCH_TIER_KEY, tier);
+      else localStorage.removeItem(SEARCH_TIER_KEY);
+    } catch (_) {
+      // storage unavailable: the next page works it out again
+    }
+  }
+
+  function rememberSearchConsent(laneId, tier) {
+    try {
+      localStorage.setItem(SEARCH_CONSENT_KEY, String(laneId));
+      if (tier) localStorage.setItem(SEARCH_TIER_KEY, String(tier));
+    } catch (_) {
+      // storage unavailable: no warm-up next visit
+    }
   }
 
   function rerunQuery() {
@@ -1566,20 +2664,267 @@ const EddieLib = {};
     consentText.textContent = lib.consentCopy({
       sizeBytes: msg.sizeBytes,
       model: short,
+      origin: msg.origin || (lane.origin || "huggingface"),
+      sidecarBytes: msg.sidecarBytes || 0,
       saveData: saveData || !!msg.saveData,
       consentText: config.consentText,
     });
     consentAccept.textContent = msg.sizeBytes == null ? "Download" : `Download ${lib.formatBytes(msg.sizeBytes)}`;
+    if (settingsOpen) setSettingsOpen(false);
     show(consentCard);
     announce("Semantic search needs a model download. " + consentText.textContent);
   }
 
-  function acceptConsent() {
+  async function acceptConsent() {
     hide(consentCard);
-    if (!worker) return;
-    setWorkerState("loading");
-    worker.postMessage({ type: "init", indexUrl, baseUrl, version, denseRuntime: config.denseRuntime, consent: true });
+    if (!search) return;
+    const tier = lib.searchTierFor({ laneKind: pendingConsentKind });
+    if (pendingConsentLane) rememberSearchConsent(pendingConsentLane, tier === "lite" ? null : tier);
     input.focus();
+    setStatus("Loading search model…", null);
+    // The lite service worker cannot host the lane: move first, then init
+    // with consent on the tier that can.
+    await switchSearchTier(tier);
+    if (!search) return;
+    postInit(true);
+  }
+
+  // -- Settings (gear) --
+  // Four preferences in one localStorage entry (lib/settings.js), each
+  // bounded by the site's data-* config.
+
+  function createGearSvg() {
+    const ns = "http://www.w3.org/2000/svg";
+    const svg = document.createElementNS(ns, "svg");
+    svg.setAttribute("viewBox", "0 0 16 16");
+    svg.setAttribute("aria-hidden", "true");
+    svg.setAttribute("fill", "none");
+    svg.setAttribute("stroke", "currentColor");
+    svg.setAttribute("stroke-width", "1.3");
+    svg.setAttribute("stroke-linecap", "round");
+    const circle = document.createElementNS(ns, "circle");
+    circle.setAttribute("cx", "8");
+    circle.setAttribute("cy", "8");
+    circle.setAttribute("r", "2.4");
+    const teeth = document.createElementNS(ns, "path");
+    teeth.setAttribute(
+      "d",
+      "M8 1v1.8M8 13.2V15M1 8h1.8M13.2 8H15M3.05 3.05l1.27 1.27M11.68 11.68l1.27 1.27M12.95 3.05l-1.27 1.27M4.32 11.68l-1.27 1.27"
+    );
+    svg.appendChild(circle);
+    svg.appendChild(teeth);
+    return svg;
+  }
+
+  /** What the panel may offer: needs the lane list and an adapter probe. */
+  async function currentChoices() {
+    const gpu = await probePageGpu();
+    return lib.settingsChoices({
+      config: siteConfig,
+      lanes: laneInfo ? laneInfo.lanes : null,
+      hostSkipped: laneInfo ? laneInfo.hostSkipped : [],
+      hasWebGpu: !!gpu,
+    });
+  }
+
+  function toggleSettings() {
+    setSettingsOpen(!settingsOpen);
+  }
+
+  async function setSettingsOpen(open) {
+    settingsOpen = !!open;
+    gearBtn.setAttribute("aria-expanded", settingsOpen ? "true" : "false");
+    if (!settingsOpen) {
+      hide(settingsCard);
+      input.focus();
+      return;
+    }
+    show(settingsCard);
+    renderSettings(await currentChoices());
+    const first = settingsCard.querySelector("input, button");
+    if (first) first.focus();
+  }
+
+  /** One radio group, or a muted line when the site and the browser leave only one answer. */
+  function settingsGroup(legend, name, options, current, onPick) {
+    if (!options || options.length === 0) return null;
+    const group = el("div", "sa-set-group");
+    group.appendChild(el("div", "sa-set-legend", legend));
+    if (options.length === 1) {
+      const only = options[0];
+      group.appendChild(el("div", "sa-set-note", `${only.label} — ${only.detail}`));
+      return group;
+    }
+    for (const opt of options) {
+      const row = el("label", "sa-set-opt");
+      const radio = document.createElement("input");
+      radio.type = "radio";
+      radio.name = "eddie-" + name;
+      radio.value = opt.value;
+      radio.checked = opt.value === current;
+      radio.addEventListener("change", () => {
+        if (radio.checked) onPick(opt.value);
+      });
+      const text = el("span");
+      text.appendChild(el("span", "sa-set-opt-main", opt.label));
+      if (opt.detail) {
+        text.appendChild(document.createTextNode(" "));
+        text.appendChild(el("span", "sa-set-opt-detail", opt.detail));
+      }
+      row.appendChild(radio);
+      row.appendChild(text);
+      group.appendChild(row);
+    }
+    return group;
+  }
+
+  function renderSettings(choices) {
+    const sel = lib.currentSelection(choices, settings, {
+      config: siteConfig,
+      activeLane: host.dataset.lane || null,
+      activeAgent: agentModel ? (/-0\.8B$/i.test(agentModel.base) ? "light" : "quality") : null,
+    });
+    settingsBody.textContent = "";
+    const groups = [
+      settingsGroup("Search model", "searchLane", choices.search, sel.searchLane, pickSearchLane),
+      settingsGroup("Answers", "agentLevel", choices.agent, sel.agentLevel, pickAgentLevel),
+      settingsGroup("Preload", "warm", choices.warm, sel.warm, (v) => pickSimple("warm", v)),
+      settingsGroup("Between pages", "persist", choices.persist, sel.persist, (v) => pickSimple("persist", v)),
+    ];
+    for (const g of groups) {
+      if (g) settingsBody.appendChild(g);
+    }
+    settingsBody.appendChild(storageSection());
+  }
+
+  /**
+   * Quota-managed storage this origin holds: the model cache, WebLLM's
+   * weights, whatever the service worker cached. Not the HTTP cache.
+   */
+  function storageSection() {
+    const wrap = el("div", "sa-set-group");
+    wrap.appendChild(el("div", "sa-set-legend", "Downloads on this device"));
+    const row = el("div", "sa-set-storage");
+    const size = el("span", "sa-set-opt-detail", "measuring…");
+    const clear = button("sa-btn", "Delete downloads", () => clearDownloads(size));
+    row.appendChild(size);
+    row.appendChild(clear);
+    wrap.appendChild(row);
+    showStorageUsage(size);
+    return wrap;
+  }
+
+  async function showStorageUsage(target) {
+    let text = "size unavailable in this browser";
+    try {
+      if (navigator.storage && navigator.storage.estimate) {
+        const { usage } = await navigator.storage.estimate();
+        text = Number(usage) > 0 ? lib.formatBytes(Number(usage)) : "nothing stored";
+      }
+    } catch (_) {
+      // leave the fallback text
+    }
+    target.textContent = text;
+  }
+
+  /**
+   * Delete every downloaded model. While a transport exists the engine holds
+   * the database open and deleteDatabase would block, so ask the engine;
+   * otherwise delete it here.
+   */
+  async function clearDownloads(target) {
+    target.textContent = "deleting…";
+    try {
+      if (search) {
+        await search.call("cache_clear", {}, { requestId: ++requestSeq, timeoutMs: 60000 });
+      } else if (window.indexedDB) {
+        await new Promise((resolve) => {
+          const req = indexedDB.deleteDatabase("eddie-models");
+          req.onsuccess = req.onerror = req.onblocked = () => resolve();
+        });
+      }
+      if (window.caches && caches.keys) {
+        for (const name of await caches.keys()) {
+          if (/webllm|mlc/i.test(name)) await caches.delete(name);
+        }
+      }
+      try {
+        localStorage.removeItem(AGENT_CONSENT_KEY);
+      } catch (_) {
+        // nothing to forget
+      }
+    } catch (err) {
+      console.warn("eddie: could not delete downloads", err);
+    }
+    showStorageUsage(target);
+    announce("Downloads deleted.");
+  }
+
+  function saveSetting(patch) {
+    settings = lib.writeSettings(localStore(), patch);
+    return settings;
+  }
+
+  /** Re-derive the effective config after a preference changed. */
+  async function applySettings() {
+    config = lib.effectiveConfig(siteConfig, settings, await currentChoices());
+  }
+
+  async function pickSearchLane(value) {
+    saveSetting({ searchLane: value });
+    await applySettings();
+    consentDeclined = false;
+    if (value === "none") {
+      // Forget the remembered lane so a later page does not warm it up again.
+      try {
+        localStorage.removeItem(SEARCH_CONSENT_KEY);
+      } catch (_) {
+        // nothing to forget
+      }
+    }
+    // The chosen lane may need a different tier than the one hosting search,
+    // and the next page should register that tier rather than the old one.
+    const lane = (laneInfo ? laneInfo.lanes : []).find((l) => l.id === value) || null;
+    const tier = lib.searchTierFor({ laneKind: lane ? lane.kind : null });
+    rememberSearchTier(tier);
+    if (!search) return;
+    await switchSearchTier(tier);
+    if (!search) return;
+    pendingConsentLane = value === "none" ? null : value;
+    pendingConsentKind = lane ? lane.kind : null;
+    postInit(value !== "none");
+  }
+
+  /** Forget the chosen agent so the next Ask re-detects it at the new level. */
+  async function reselectAgent() {
+    agentInfo = null;
+    agentModel = null;
+    askBtn.hidden = true;
+    askHint.hidden = true;
+    if (agent) {
+      agent.terminate();
+      agent = null;
+    }
+    await detectAgent();
+  }
+
+  async function pickAgentLevel(value) {
+    saveSetting({ agentLevel: value });
+    await applySettings();
+    await reselectAgent();
+  }
+
+  async function pickSimple(field, value) {
+    saveSetting({ [field]: value });
+    await applySettings();
+  }
+
+  async function resetSettings() {
+    settings = lib.clearSettings(localStore());
+    await applySettings();
+    await reselectAgent();
+    renderSettings(await currentChoices());
+    announce("Settings reset to this site's defaults.");
   }
 
   function declineConsent() {
@@ -1607,32 +2952,27 @@ const EddieLib = {};
   }
 
   async function doSearch(query, explicit) {
-    if (!searchable || !worker) return;
+    if (!searchable || !search) return;
     // A different query cancels a running answer; re-searching the question
     // being answered (a late debounce, a re-run after init) does not.
     if (agentRun && !agentRun.done && query !== agentRun.question) abortAgent("new search");
     lastSearchedQuery = query;
-    const requestId = ++requestSeq;
-    activeSearchId = requestId;
-    pending.set(requestId, {
-      resolve: (msg) => {
-        if (requestId !== activeSearchId) return;
-        renderSearchResult(msg, query);
-      },
-      reject: (err) => {
-        if (requestId !== activeSearchId) return;
-        showSearchError(err.message || "Search failed");
-      },
-    });
-    worker.postMessage({
-      type: "search",
-      requestId,
-      query,
-      topK: config.topK,
-      mode: "hybrid",
-      qa: wantQa(query) ? Math.max(1, Math.min(config.answerTopK, 3)) : 0,
-      explicit: !!explicit,
-    });
+    const token = ++requestSeq;
+    activeSearchId = token;
+    try {
+      const msg = await callWorker("search", {
+        query,
+        topK: config.topK,
+        mode: "hybrid",
+        qa: wantQa(query) ? Math.max(1, Math.min(config.answerTopK, 3)) : 0,
+        explicit: !!explicit,
+      });
+      if (token !== activeSearchId) return;
+      renderSearchResult(msg, query);
+    } catch (err) {
+      if (token !== activeSearchId) return;
+      showSearchError((err && err.message) || "Search failed");
+    }
   }
 
   function renderSearchResult(msg, query) {
@@ -1789,21 +3129,13 @@ const EddieLib = {};
   // -- Agent --
   async function detectAgent() {
     if (agentInfo !== null) return agentInfo;
-    agentInfo = false;
-    if (config.agentMode === "off" || !navigator.gpu || typeof navigator.gpu.requestAdapter !== "function") {
+    if (config.agentMode === "off") {
+      agentInfo = false;
       return agentInfo;
     }
-    try {
-      const adapter = await navigator.gpu.requestAdapter();
-      if (adapter) {
-        agentInfo = {
-          maxBufferSize: adapter.limits ? adapter.limits.maxBufferSize : 0,
-          hasF16: !!(adapter.features && adapter.features.has("shader-f16")),
-        };
-      }
-    } catch (err) {
-      console.warn("eddie: WebGPU adapter probe failed", err);
-    }
+    const gpu = await probePageGpu();
+    if (agentInfo !== null) return agentInfo;
+    agentInfo = gpu ? { maxBufferSize: gpu.maxBufferSize, hasF16: gpu.hasF16 } : false;
     if (agentInfo) {
       agentModel = lib.selectAgentModel({
         mode: config.agentModel,
@@ -1954,12 +3286,41 @@ const EddieLib = {};
     });
   }
 
-  function ensureAgentWorker() {
-    if (agentWorker) return;
-    agentWorker = new Worker(lib.assetUrl(baseUrl, "eddie-agent-worker.js", version), { type: "module" });
-    agentWorker.onmessage = (e) => onAgentMessage(e.data || {});
-    agentWorker.onerror = (e) => {
-      const message = e && e.message ? e.message : "agent worker failed to load";
+  /** The agent transport: the service worker when it has WebGPU, else a page-side module worker. */
+  function ensureAgentTransport() {
+    if (agent) return Promise.resolve(agent);
+    if (agentCreating) return agentCreating;
+    agentCreating = (async () => {
+      // The agent always lives in the agent tier (WebLLM is only imported
+      // there), whose worker is registered here, on the first Ask after
+      // consent: the search tiers never fetch WebLLM.
+      const plan = await withDeadline(ensureTransportPlan("agent"), TRANSPORT_WAIT_MS);
+      if (agent) return agent;
+      let t = null;
+      if (plan && plan.kind === "sw" && plan.hello && plan.hello.gpu && plan.sw && !plan.sw.closed && !forcePageWorkers) {
+        t = plan.sw;
+      } else if (plan && plan.sw) {
+        // Connected, but unusable for the agent (no WebGPU in the worker's scope).
+        console.info("eddie: agent falls back to a page worker");
+        plan.sw.terminate();
+      }
+      if (!t) t = new lib.DedicatedWorkerTransport(lib.assetUrl(baseUrl, "eddie-agent-worker.js", lib.ASSET_VERSION), { type: "module" });
+      attachAgent(t);
+      return t;
+    })().finally(() => {
+      agentCreating = null;
+    });
+    return agentCreating;
+  }
+
+  function attachAgent(t) {
+    agent = t;
+    host.dataset.agentTransport = t.kind;
+    for (const type of ["progress", "loaded", "plan_result", "token", "done", "aborted", "error"]) {
+      t.on(type, onAgentMessage);
+    }
+    t.on("crash", (msg) => {
+      const message = msg.message || "agent worker failed to load";
       if (agentPendingLoad) {
         agentPendingLoad.reject(new Error(message));
         agentPendingLoad = null;
@@ -1968,30 +3329,67 @@ const EddieLib = {};
         agentRun.done = true;
         showAnswerError(message, agentRun.question);
       }
-    };
+    });
+    t.on("reset", () => {
+      // The service worker restarted: its model is gone; the next Ask loads again.
+      console.info("eddie: agent engine restarted");
+      agentLoaded = false;
+      if (agentPendingLoad) {
+        agentPendingLoad.reject(new Error("the answer engine restarted"));
+        agentPendingLoad = null;
+      }
+      if (agentRun && !agentRun.done) {
+        agentRun.done = true;
+        if (agentRun.rejectStream) agentRun.rejectStream(new Error("the answer engine restarted"));
+      }
+    });
   }
 
   function loadAgent(run) {
     if (agentLoaded) return Promise.resolve();
     if (agentLoading) return agentLoading;
-    ensureAgentWorker();
-    agentLoading = new Promise((resolve, reject) => {
-      agentPendingLoad = { resolve, reject };
-      answerProgress.textContent = `Loading ${agentModel.base}…`;
-      announce(`Loading the answer model, ${agentModel.base}`);
-      agentWorker.postMessage({ type: "load", model: agentModel.id });
-    }).finally(() => {
+    agentLoading = (async () => {
+      const t = await ensureAgentTransport();
+      if (run.aborted) return;
+      if (t.kind === "sw") {
+        // The service worker may still hold the model from an earlier page
+        // (or may have been stopped meanwhile: reconnect first).
+        try {
+          if (!(await t.ensureAlive(lib.IDLE_PING_TIMEOUT_MS))) throw new Error("the answer engine is unreachable");
+          const st = await t.state();
+          if (lib.canReuseAgent(st.agent, agentModel.id)) {
+            agentLoaded = true;
+            host.dataset.agentReused = "true";
+            console.info("eddie agent: reusing " + agentModel.id + " from the service worker");
+            return;
+          }
+        } catch (err) {
+          console.warn("eddie agent: state query failed", err);
+        }
+      }
+      host.dataset.agentReused = "false";
+      await new Promise((resolve, reject) => {
+        agentPendingLoad = { resolve, reject };
+        answerProgress.textContent = `Loading ${agentModel.base}…`;
+        announce(`Loading the answer model, ${agentModel.base}`);
+        t.postRaw({ type: "load", model: agentModel.id });
+      });
+    })().finally(() => {
       agentLoading = null;
     });
     return agentLoading;
   }
 
-  const agentPending = new Map();
-  function agentCall(type, payload) {
-    return new Promise((resolve, reject) => {
-      agentPending.set(payload.requestId, { resolve, reject });
-      agentWorker.postMessage(Object.assign({ type }, payload));
-    });
+  /** A plan request; a "model not loaded" reply (service worker restarted) reloads once and retries. */
+  async function agentCall(type, payload) {
+    try {
+      return await agent.call(type, payload, { requestId: payload.requestId });
+    } catch (err) {
+      if (!err || !lib.isModelNotLoadedMessage(err.message)) throw err;
+      agentLoaded = false;
+      await loadAgent({ aborted: false });
+      return agent.call(type, payload, { requestId: ++requestSeq });
+    }
   }
 
   function streamAnswer(run) {
@@ -2006,7 +3404,8 @@ const EddieLib = {};
       caret.setAttribute("aria-hidden", "true");
       run.caret = caret;
       answerText.appendChild(caret);
-      agentWorker.postMessage({ type: "ask", requestId: run.requestId, question: run.question, site: siteName, evidence: run.evidence });
+      updateKeepalive();
+      agent.postRaw({ type: "ask", requestId: run.requestId, question: run.question, site: siteName, evidence: run.evidence });
     });
   }
 
@@ -2038,8 +3437,7 @@ const EddieLib = {};
         }
         break;
       case "plan_result":
-        resolveAgent(msg);
-        break;
+        break; // settled by the transport's call()
       case "token":
         if (agentRun && msg.requestId === agentRun.requestId && !agentRun.done) {
           agentRun.text += msg.text;
@@ -2056,11 +3454,7 @@ const EddieLib = {};
         }
         break;
       case "error":
-        if (msg.requestId != null && agentPending.has(msg.requestId)) {
-          const p = agentPending.get(msg.requestId);
-          agentPending.delete(msg.requestId);
-          p.reject(new Error(msg.message || "agent request failed"));
-        } else if (agentPendingLoad) {
+        if (agentPendingLoad && msg.requestId == null) {
           agentPendingLoad.reject(new Error(msg.message || "model load failed"));
           agentPendingLoad = null;
         } else if (agentRun && !agentRun.done && (msg.requestId == null || msg.requestId === agentRun.requestId)) {
@@ -2073,13 +3467,6 @@ const EddieLib = {};
     }
   }
 
-  function resolveAgent(msg) {
-    const p = agentPending.get(msg.requestId);
-    if (!p) return;
-    agentPending.delete(msg.requestId);
-    p.resolve(msg);
-  }
-
   function finishAnswer(run, msg) {
     run.done = true;
     clearAnswerActions();
@@ -2112,6 +3499,7 @@ const EddieLib = {};
     run.usage = usage;
     announce(msg.nohit ? "No answer: the site doesn't cover that." : "Answer ready. " + msg.answer);
     if (run.resolveStream) run.resolveStream();
+    updateKeepalive();
     console.info("eddie agent " + JSON.stringify({
       question: run.question,
       model: agentModel ? agentModel.id : null,
@@ -2122,7 +3510,10 @@ const EddieLib = {};
       totalMs: usage.totalMs,
       tps: usage.tps,
       sinceAskMs: Math.round(performance.now() - run.started),
+      agentReused: host.dataset.agentReused === "true",
+      transport: agent ? agent.kind : null,
     }));
+    host.dataset.agentDoneMs = String(Math.round(performance.now()));
   }
 
   function renderAnswerText(text, citations) {
@@ -2152,10 +3543,9 @@ const EddieLib = {};
     console.debug("eddie agent abort " + reason + " " + run.requestId);
     run.aborted = true;
     run.done = true;
-    if (agentWorker) agentWorker.postMessage({ type: "abort", requestId: run.requestId });
-    agentPending.forEach((p) => p.reject(new Error("aborted")));
-    agentPending.clear();
+    if (agent) agent.postRaw({ type: "abort", requestId: run.requestId });
     if (run.resolveStream) run.resolveStream();
+    updateKeepalive();
     if (reason === "stopped") {
       paintStream(run, true);
       clearAnswerActions();
@@ -2187,7 +3577,9 @@ const EddieLib = {};
 
   // -- Modal open/close --
   function openModal() {
+    if (isOpen) return;
     isOpen = true;
+    rememberSearchUsed();
     rotateHeartSprite();
     backdrop.classList.add("sa-open");
     trigger.style.display = "none";
@@ -2197,17 +3589,20 @@ const EddieLib = {};
     hide(answerCard);
     ensureWorker();
     detectAgent();
+    updateKeepalive();
     requestAnimationFrame(() => input.focus());
   }
 
   function closeModal() {
     if (!isOpen) return;
     isOpen = false;
+    if (settingsOpen) setSettingsOpen(false);
     clearTimeout(searchTimer);
     abortAgent("closed");
     backdrop.classList.remove("sa-open");
     trigger.style.display = "";
     trigger.focus();
+    updateKeepalive();
   }
 
   function applyTriggerOffsets() {
@@ -2321,7 +3716,38 @@ const EddieLib = {};
     openModal();
   });
 
+  // A page going away tells the service worker to drop its ports and stop
+  // any answer it is still generating for us.
+  window.addEventListener("pagehide", () => {
+    if (agentRun && !agentRun.done && agent) agent.postRaw({ type: "abort", requestId: agentRun.requestId });
+    for (const t of [search, agent]) {
+      if (!t || t.kind !== "sw") continue;
+      try {
+        t.postRaw({ type: "disconnect" });
+      } catch (_) {
+        // port already gone
+      }
+    }
+  });
+
   // -- Mount --
   document.body.appendChild(host);
+  host.dataset.persist = config.persist;
+  host.dataset.warm = config.warm;
+  host.dataset.boot = scriptEl.getAttribute("data-boot") || "";
+  window.eddie = Object.assign(window.eddie || {}, { open: openModal, close: closeModal });
+  // Handed over from eddie-boot.js: drop its trigger and honour a click or
+  // shortcut that arrived while this script was loading.
+  const boot = window.__eddieBoot;
+  if (boot && typeof boot.dispose === "function") {
+    const wantOpen = !!boot.open;
+    boot.dispose();
+    if (wantOpen) openModal();
+  }
+  afterLoad(() =>
+    onIdle(() => {
+      warmUp().catch((err) => console.warn("eddie warm-up failed", err));
+    })
+  );
 })();
 })();