diff --git a/CLAUDE.md b/CLAUDE.md
index 5cd2e44..99260d4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -439,13 +439,17 @@ tests/
   console-crane-bridge.test.ts      # window CustomEvent emit/listen contracts
   console-crane-store.test.ts       # toggleConsoleCrane / goBack / canGoBack / isOnMainPage
   translate.service.test.ts         # cache hit/miss + 24h TTL eviction (vi.useFakeTimers)
+  translate-analytics-args.test.ts  # install id (deviceId) and trigger sent with translation calls (E-01, E-05)
   settings-host.test.ts             # nibbleDisabledDomains normalize / toggle
   language-detection.test.ts        # RTL detection, title lookup, supported codes
   selection-popup.test.ts           # @mousedown.prevent.stop regression
+  caption-translation-gate.test.ts  # whole-caption translation: settle ~150 ms, skip the caption already sent (E-06); in-flight sharing is in translate.service.test.ts (E-04)
   nibble-surface.test.ts            # bridge-driven hide/show
   translate-card.test.ts            # popup translate input flow
   login-password.test.ts            # popup password form (ENABLE_PASSWORD_AUTH=true)
   login-password-disabled.test.ts   # popup password form hidden when flag is unset
+  login-analytics.test.ts           # user_logged-in source, login_failed source + reason (E-03)
+  save-login-prompt.test.ts         # "Login to save" prompt viewed once per word view, clicked (E-03)
   language-state.test.ts            # round-1 rules: dark gate, own language, save row, plan limit, deep link
   language-catalog.test.ts          # one RTL list, picker names, bundled Vazirmatn
   own-language.test.ts              # translate request with / without a server profile; language store
@@ -454,6 +458,7 @@ tests/
   language-lookups.test.ts          # saved-phrase lookup, bundle suggestion, last-used bundles per language
   language-analytics.test.ts        # learning_language and target_language super properties
   tab-broadcast.test.ts             # tab broadcast skips tabs without our content scripts quietly
+  install-tracking.test.ts          # onInstalled: extension_installed / extension_updated + welcome page (E-02)
   e2e/
     extension-fixture.ts            # chromium.launchPersistentContext + extension load
     server.mjs                      # static fixtures HTTP server
diff --git a/src/background.ts b/src/background.ts
index 20a3a2f..603b44f 100644
--- a/src/background.ts
+++ b/src/background.ts
@@ -9,6 +9,7 @@ import {
   MESSAGE_TYPE,
 } from "./common/types/messaging";
 import { ensureStoredTargetLanguage } from "./common/helper/default-language";
+import { handleInstalled } from "./common/helper/install-tracking";
 
 export {};
 
@@ -20,6 +21,14 @@ chrome.runtime.onInstalled.addListener(() => {
   );
 });
 
+// Track installs and updates on the install's analytics id, and open the
+// welcome page on a first install (E-02, see install-tracking.ts).
+chrome.runtime.onInstalled.addListener((details) => {
+  handleInstalled(details).catch((e) =>
+    log("background: install tracking failed", e)
+  );
+});
+
 function getOAuthToken() {
   return new Promise((resolve, reject) => {
     chrome.identity.getAuthToken({ interactive: true }, function (token) {
@@ -106,8 +115,13 @@ chrome.runtime.onMessage.addListener(function (request, _sender, sendResponse) {
       const left = screen.width / 2 - width / 2;
       const top = screen.height / 2 - height / 2;
 
+      // The login source rides on the hash route's query (E-03).
+      const query = request.source
+        ? `?source=${encodeURIComponent(request.source)}`
+        : "";
+
       chrome.windows.create({
-        url: chrome.runtime.getURL("popup.html") + "#/login",
+        url: chrome.runtime.getURL("popup.html") + "#/login" + query,
         type: "popup",
         width: width,
         height: height,
diff --git a/src/common/helper/install-id.ts b/src/common/helper/install-id.ts
new file mode 100644
index 0000000..cc14d3c
--- /dev/null
+++ b/src/common/helper/install-id.ts
@@ -0,0 +1,57 @@
+/**
+ * The install's analytics id (A3 in the analytics work list): one random id
+ * per install, kept in chrome.storage.local under `analyticsAnonymousId`.
+ *
+ * Mixpanel uses it as the anonymous `distinct_id` / `$device_id`
+ * (plugins/mixpanel.ts), and server calls that fire an analytics event send it
+ * as `deviceId` (E-01) so server events land on the same person.
+ *
+ * This module has no mixpanel import, so it is safe in every context: content
+ * scripts, the popup and the background service worker.
+ */
+
+export const ANON_ID_KEY = "analyticsAnonymousId";
+
+/** crypto.randomUUID is missing on plain-http pages; getRandomValues is not. */
+export function newAnonymousId(): string {
+  const b = crypto.getRandomValues(new Uint8Array(16));
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+
+// One read-or-create at a time per context, so two callers on the first page
+// ever do not mint two different ids.
+let pending: Promise<string | undefined> | null = null;
+
+/**
+ * Read the stored install id, creating and storing it when there is none yet.
+ * Not cached after it settles: logout rotates the id (resetAnalyticsIdentity),
+ * and the next call must see the new one.
+ *
+ * Resolves `undefined` only when there is no extension context (e.g. the
+ * content script was orphaned by an update); callers then send no id.
+ */
+export function getInstallId(): Promise<string | undefined> {
+  if (pending) return pending;
+  pending = new Promise<string | undefined>((resolve) => {
+    try {
+      chrome.storage.local.get(ANON_ID_KEY, (data) => {
+        let id = data?.[ANON_ID_KEY] as string | undefined;
+        if (id) return resolve(id);
+        id = newAnonymousId();
+        try {
+          chrome.storage.local.set({ [ANON_ID_KEY]: id }, () => resolve(id));
+        } catch {
+          resolve(id);
+        }
+      });
+    } catch {
+      resolve(undefined);
+    }
+  }).finally(() => {
+    pending = null;
+  });
+  return pending;
+}
diff --git a/src/common/helper/install-tracking.ts b/src/common/helper/install-tracking.ts
new file mode 100644
index 0000000..db15d88
--- /dev/null
+++ b/src/common/helper/install-tracking.ts
@@ -0,0 +1,125 @@
+/**
+ * Install and update tracking for the background service worker (E-02).
+ *
+ * mixpanel-browser is not loaded here: it expects `window` and `document`,
+ * which a MV3 service worker does not have. So the two events go straight to
+ * Mixpanel's /track endpoint with fetch, in the same shape mixpanel-browser
+ * sends (base64 JSON in a `data` form field), through the same
+ * MIXPANEL_API_HOST proxy, on the install's analytics id. The content scripts
+ * use that same id as their anonymous `distinct_id` (plugins/mixpanel.ts), so
+ * these events join the rest of the install's events.
+ */
+import { getInstallId } from "./install-id";
+import { log } from "./log";
+
+/** The welcome page opened on first install (landing D-01 reads install_id). */
+export const WELCOME_URL = "https://subturtle.app/";
+
+export function welcomeUrl(installId: string): string {
+  const params = new URLSearchParams({
+    install_id: installId,
+    utm_source: "extension",
+    utm_medium: "install",
+  });
+  return `${WELCOME_URL}?${params.toString()}`;
+}
+
+const DEFAULT_API_HOST = "https://api-js.mixpanel.com";
+
+function insertId(): string {
+  const b = crypto.getRandomValues(new Uint8Array(12));
+  return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+}
+
+/** UTF-8 safe base64, the encoding mixpanel-browser 2.45 uses for `data`. */
+function base64Json(value: unknown): string {
+  const bytes = new TextEncoder().encode(JSON.stringify(value));
+  let bin = "";
+  bytes.forEach((b) => (bin += String.fromCharCode(b)));
+  return btoa(bin);
+}
+
+/**
+ * Send one event to Mixpanel from a context without mixpanel-browser.
+ * Never throws: analytics must not break install handling.
+ */
+export async function trackFromBackground(
+  event: string,
+  installId: string,
+  properties: Record<string, unknown> = {}
+): Promise<void> {
+  const token = process.env.MIXPANEL_PROJECT_TOKEN;
+  if (!token) return;
+  const host = (process.env.MIXPANEL_API_HOST || DEFAULT_API_HOST).replace(
+    /\/+$/,
+    ""
+  );
+  const manifest = chrome.runtime.getManifest();
+  const payload = {
+    event,
+    properties: {
+      token,
+      // Same identity the content scripts register for an anonymous install.
+      distinct_id: installId,
+      $device_id: installId,
+      time: Date.now() / 1000,
+      $insert_id: insertId(),
+      app: "chrome-extension",
+      version: manifest.version_name || manifest.version,
+      ...properties,
+    },
+  };
+  try {
+    await fetch(`${host}/track/?ip=1`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: `data=${encodeURIComponent(base64Json(payload))}`,
+    });
+  } catch (e) {
+    log("background: analytics request failed", e);
+  }
+}
+
+/**
+ * Web Store installs carry `update_url` in the manifest; an unpacked build
+ * (local dev, the CI e2e run, a dev zip loaded by hand) does not.
+ */
+function isStoreInstall(): boolean {
+  return "update_url" in chrome.runtime.getManifest();
+}
+
+/**
+ * chrome.runtime.onInstalled handler: `extension_installed` on a new install
+ * (and open the welcome page), `extension_updated` with `previous_version` on
+ * an update. Other reasons (a Chrome update) are ignored.
+ */
+export async function handleInstalled(
+  details: chrome.runtime.InstalledDetails
+): Promise<void> {
+  const { reason, previousVersion } = details;
+  if (reason !== "install" && reason !== "update") return;
+
+  const installId = await getInstallId();
+  if (!installId) return;
+
+  if (reason === "install") {
+    // Open the page first: it must not wait on the analytics request.
+    // Unpacked builds skip it, so dev reloads and CI runs do not open
+    // subturtle.app or count fake installs on the landing page.
+    if (isStoreInstall()) {
+      try {
+        await chrome.tabs.create({ url: welcomeUrl(installId) });
+      } catch (e) {
+        log("background: failed to open the welcome page", e);
+      }
+    }
+    await trackFromBackground("extension_installed", installId, {
+      reason: "install",
+    });
+  } else {
+    await trackFromBackground("extension_updated", installId, {
+      reason: "update",
+      previous_version: previousVersion || null,
+    });
+  }
+}
diff --git a/src/common/services/translate.service.ts b/src/common/services/translate.service.ts
index 33e4163..2860ab3 100644
--- a/src/common/services/translate.service.ts
+++ b/src/common/services/translate.service.ts
@@ -12,6 +12,18 @@ import { resolveTranslationLanguage } from "../language/state";
 import { languageName } from "../language/catalog";
 import type { LanguageState } from "../language/types";
 import { toSupportedLanguageCode } from "../helper/default-language";
+import { getInstallId } from "../helper/install-id";
+
+/**
+ * What asked for a translation (E-05). Sent as `trigger` so the server's
+ * `translation_requested` event can split requests by source (B-03).
+ */
+export type TranslationTrigger =
+  | "caption"
+  | "word"
+  | "selection"
+  | "definition"
+  | "detail";
 
 // Cache interface for translation results
 interface TranslationCache {
@@ -36,6 +48,8 @@ export class TranslateService {
   // Cache for translation results
   private translationCache: TranslationCache = {};
   private readonly CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+  // Requests on their way, by cache key (E-04).
+  private inFlight = new Map<string, Promise<any>>();
 
   /**
    * The learner's own language code, the one translations are written in.
@@ -135,6 +149,28 @@ export class TranslateService {
     };
   }
 
+  /**
+   * E-04: register a request as in flight, so an identical call made before
+   * it answers waits for it instead of sending a second request. The entry is
+   * removed when the request settles, so a failure is never reused or cached.
+   */
+  private startInFlight(cacheKey: string) {
+    let resolve!: (value: any) => void;
+    let reject!: (reason: unknown) => void;
+    const promise = new Promise<any>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    // Nobody may be waiting on it: a failure here must not be "unhandled".
+    promise.catch(() => {});
+    this.inFlight.set(cacheKey, promise);
+    const settle = () => this.inFlight.delete(cacheKey);
+    return {
+      resolve: (value: any) => (settle(), resolve(value)),
+      reject: (reason: unknown) => (settle(), reject(reason)),
+    };
+  }
+
   // Clean expired cache entries
   private cleanExpiredCache(): void {
     const now = Date.now();
@@ -145,7 +181,26 @@ export class TranslateService {
     });
   }
 
-  async fetchSimpleTranslation(text: string | string[], context: string = "") {
+  /**
+   * Analytics args for calls that fire a server event (E-01, E-05). `userId`
+   * stays for old servers; `deviceId` is the install's analytics id, read
+   * from storage on each call so it is never empty while the id loads and
+   * follows the new id after logout.
+   */
+  private async analyticsArgs(trigger?: TranslationTrigger) {
+    const deviceId = await getInstallId();
+    return {
+      userId: authentication.user?.id,
+      ...(deviceId ? { deviceId } : {}),
+      ...(trigger ? { trigger } : {}),
+    };
+  }
+
+  async fetchSimpleTranslation(
+    text: string | string[],
+    context: string = "",
+    trigger?: TranslationTrigger
+  ) {
     // Clean expired cache entries
     this.cleanExpiredCache();
 
@@ -160,8 +215,14 @@ export class TranslateService {
       return cachedResult;
     }
 
+    // The same request is already on its way: share it (E-04).
+    const pending = this.inFlight.get(cacheKey);
+    if (pending) return pending;
+    const inFlight = this.startInFlight(cacheKey);
+
     // If not cached, fetch from API
     try {
+      const analytics = await this.analyticsArgs(trigger);
       const result = await withAuthRetry(() =>
         functionProvider.run<string>({
           name: "translateWithContext",
@@ -173,23 +234,29 @@ export class TranslateService {
             phrase: text,
             context: context || "",
             // For the server-side translation_requested analytics event.
-            userId: authentication.user?.id,
+            ...analytics,
           },
         })
       );
 
       // Cache the result
       this.cacheResult(cacheKey, result);
+      inFlight.resolve(result);
 
       return result;
     } catch (error) {
       // Log error but don't cache failed requests
       console.error("Translation error:", error);
+      inFlight.reject(error);
       throw error;
     }
   }
 
-  async fetchDetailedTranslation(text: string, context: string = "") {
+  async fetchDetailedTranslation(
+    text: string,
+    context: string = "",
+    trigger: TranslationTrigger = "detail"
+  ) {
     // Clean expired cache entries
     this.cleanExpiredCache();
 
@@ -204,8 +271,14 @@ export class TranslateService {
       return cachedResult;
     }
 
+    // The same request is already on its way: share it (E-04).
+    const pending = this.inFlight.get(cacheKey);
+    if (pending) return pending;
+    const inFlight = this.startInFlight(cacheKey);
+
     // If not cached, fetch from API
     try {
+      const analytics = await this.analyticsArgs(trigger);
       const data = await withAuthRetry(() =>
         functionProvider.run<LanguageLearningData>({
           name: "translateWithContext",
@@ -217,7 +290,7 @@ export class TranslateService {
             phrase: text,
             context: context || "",
             // For the server-side translation_requested analytics event.
-            userId: authentication.user?.id,
+            ...analytics,
           },
         })
       );
@@ -229,11 +302,13 @@ export class TranslateService {
 
       // Cache the result
       this.cacheResult(cacheKey, data);
+      inFlight.resolve(data);
 
       return data;
     } catch (error) {
       // Log error but don't cache failed requests
       console.error("Detailed translation error:", error);
+      inFlight.reject(error);
       throw error;
     }
   }
@@ -250,6 +325,7 @@ export class TranslateService {
     history?: { role: "user" | "assistant"; text: string }[];
   }): Promise<TranslationAdvice> {
     const targetLanguage = await this.requireLanguageTitle();
+    const { deviceId } = await this.analyticsArgs();
     return withAuthRetry(() =>
       functionProvider.run<TranslationAdvice>({
         name: "translationAdvice",
@@ -262,6 +338,7 @@ export class TranslateService {
           sourceLanguage: "auto",
           targetLanguage,
           ...this.translationLanguageArg(),
+          ...(deviceId ? { deviceId } : {}),
         },
       })
     );
diff --git a/src/common/types/messaging.ts b/src/common/types/messaging.ts
index c80cd62..8ae1fa1 100644
--- a/src/common/types/messaging.ts
+++ b/src/common/types/messaging.ts
@@ -74,11 +74,21 @@ export class StoreUserTokenMessage implements BaseMessage {
   }
 }
 
+/**
+ * Where a login started (E-03). The background puts it on the login window's
+ * URL (`popup.html#/login?source=…`) so LoginView can send it with
+ * `user_logged-in` and `login_failed`. A login opened from the toolbar popup
+ * itself has no source on the URL and counts as "popup".
+ */
+export type LoginSource = "save_prompt" | "practice" | "popup";
+
 export class OpenLoginWindowMessage implements BaseMessage {
   type: string;
+  source?: LoginSource;
 
-  constructor() {
+  constructor(source?: LoginSource) {
     this.type = MESSAGE_TYPE.OPEN_LOGIN_WINDOW;
+    if (source) this.source = source;
   }
 
   static is(message: any): message is OpenLoginWindowMessage {
diff --git a/src/console-crane/components/SaveWordSectionV2.vue b/src/console-crane/components/SaveWordSectionV2.vue
index 2f0b85a..e85b2ce 100644
--- a/src/console-crane/components/SaveWordSectionV2.vue
+++ b/src/console-crane/components/SaveWordSectionV2.vue
@@ -115,6 +115,7 @@ import {
   getSubturtleDashboardUrlWithToken,
 } from "../../common/static/global";
 import { TranslateService } from "../../common/services/translate.service";
+import { getInstallId } from "../../common/helper/install-id";
 import { PhraseType, PhraseBundleType } from "../../common/types/phrase.type";
 import { useDefaultBundleStore } from "../../stores/default-bundle";
 import { useProfileStore } from "../../stores/profile";
@@ -546,11 +547,14 @@ async function savePhrase(kind?: "saved" | "savedInstead") {
       return;
     }
 
+    // The install's analytics id, for the server's first-save event (E-01).
+    const deviceId = await getInstallId();
     const result = await functionProvider
       .run<PhraseType>({
         name: "createPhrase",
         args: {
           ...phraseArgs(),
+          ...(deviceId ? { deviceId } : {}),
           bundleIds: toAdd,
           // Round 1 (E-07): the language it is saved to. Only with language
           // profiles; an old server resolves it itself (B-25).
diff --git a/src/console-crane/modules/practice-config/index.vue b/src/console-crane/modules/practice-config/index.vue
index 395e9b9..18b48ce 100644
--- a/src/console-crane/modules/practice-config/index.vue
+++ b/src/console-crane/modules/practice-config/index.vue
@@ -324,7 +324,7 @@ function upgrade() {
 /** Logged out — open the login window; the isLogin watch advances the page. */
 function handleLoginRequest() {
   analytic.track("practice-now_login-clicked");
-  sendMessage(new OpenLoginWindowMessage());
+  sendMessage(new OpenLoginWindowMessage("practice"));
 }
 
 function start() {
diff --git a/src/console-crane/modules/word-detail/index.vue b/src/console-crane/modules/word-detail/index.vue
index e4e45a8..978d042 100644
--- a/src/console-crane/modules/word-detail/index.vue
+++ b/src/console-crane/modules/word-detail/index.vue
@@ -249,7 +249,7 @@
 
       <!-- Login prompt: only when there's a translation worth saving -->
       <button
-        v-else-if="!isLogin && wordData?.translation?.phrase"
+        v-else-if="showLoginPrompt"
         type="button"
         class="self-center inline-flex items-center gap-2 px-5 py-2.5 rounded-full bg-gradient-to-r from-pink-500 to-purple-600 text-white text-sm font-semibold shadow-sm hover:from-pink-600 hover:to-purple-700 transition"
         @click="handleLoginRequest"
@@ -324,6 +324,10 @@ onActivated(() => {
     return;
   }
   analytic.track("word-detail-page_viewed");
+  // A new view of the same word: the prompt may already be on screen, so the
+  // watch below would not fire again.
+  loginPromptTracked = false;
+  trackLoginPromptView();
 });
 
 /**
@@ -365,6 +369,24 @@ const frameSize = inject<{ width: number; height: number }>("frameSize");
 // Main state variables
 const wordData = ref<LanguageLearningData | null>(null); // Stores detailed linguistic data
 
+/**
+ * "Login to save this phrase" (E-03). `save-login-prompt_viewed` fires once
+ * per word view, when the button first shows: a new word or a new view resets
+ * it, a sign-in state flip or a re-render does not.
+ */
+const showLoginPrompt = computed(
+  () => !isLogin.value && !!wordData.value?.translation?.phrase
+);
+let loginPromptTracked = false;
+
+function trackLoginPromptView() {
+  if (loginPromptTracked || !showLoginPrompt.value) return;
+  loginPromptTracked = true;
+  analytic.track("save-login-prompt_viewed");
+}
+
+watch(showLoginPrompt, trackLoginPromptView);
+
 const pending = ref(false); // Loading state
 const error = ref<string | null>(null); // Translation error message, null when ok
 const key = ref(new Date().getTime()); // Key for forcing component refresh
@@ -684,6 +706,7 @@ watch(
   (value) => {
     key.value = new Date().getTime();
     wordData.value = null;
+    loginPromptTracked = false;
     error.value = null;
     lastSavedLanguage.value = null;
 
@@ -733,7 +756,8 @@ async function fetchWordDetail() {
 
     wordData.value = await TranslateService.instance.fetchDetailedTranslation(
       cleaned,
-      context
+      context,
+      "detail"
     );
   } catch (err: any) {
     console.error("Failed to fetch translation:", err);
@@ -758,7 +782,8 @@ function retryFetch() {
  * Opens login window via messaging system
  */
 function handleLoginRequest() {
-  sendMessage(new OpenLoginWindowMessage());
+  analytic.track("save-login-prompt_clicked");
+  sendMessage(new OpenLoginWindowMessage("save_prompt"));
 }
 </script>
 
diff --git a/src/nibble/components/SelectionPopup.vue b/src/nibble/components/SelectionPopup.vue
index a6919f5..e741561 100644
--- a/src/nibble/components/SelectionPopup.vue
+++ b/src/nibble/components/SelectionPopup.vue
@@ -228,7 +228,8 @@ async function onIconClick(e: MouseEvent) {
   try {
     const result = await TranslateService.instance.fetchSimpleTranslation(
       props.text,
-      props.context
+      props.context,
+      "selection"
     );
     translation.value = String(result ?? "").trim();
     mode.value = translation.value ? "translated" : "error";
diff --git a/src/plugins/mixpanel.ts b/src/plugins/mixpanel.ts
index d8bd3f2..3a12208 100644
--- a/src/plugins/mixpanel.ts
+++ b/src/plugins/mixpanel.ts
@@ -1,4 +1,5 @@
 import mixpanel, { Config } from "mixpanel-browser";
+import { ANON_ID_KEY, newAnonymousId } from "../common/helper/install-id";
 
 /**
  * NO STORAGE ON THE HOST PAGE. This module runs inside content scripts, where
@@ -29,16 +30,7 @@ mixpanel.register({
 });
 export const analytic = mixpanel;
 
-export const ANON_ID_KEY = "analyticsAnonymousId";
-
-/** crypto.randomUUID is missing on plain-http pages; getRandomValues is not. */
-function newAnonymousId(): string {
-  const b = crypto.getRandomValues(new Uint8Array(16));
-  b[6] = (b[6] & 0x0f) | 0x40;
-  b[8] = (b[8] & 0x3f) | 0x80;
-  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
-}
+export { ANON_ID_KEY };
 
 function useAnonymousId(id: string) {
   // identify() may already have run (a logged-in user whose profile loaded
@@ -48,10 +40,11 @@ function useAnonymousId(id: string) {
 }
 
 /**
- * Load (or create) the per-install anonymous id. Events tracked in the few
- * milliseconds before the storage read answers carry mixpanel's random
- * per-page id. Two scripts creating the id at once on the first page ever
- * can disagree once; the last write wins from then on.
+ * Load (or create) the per-install anonymous id. The key and format live in
+ * helper/install-id.ts, which server calls use to send it as `deviceId`.
+ * Events tracked in the few milliseconds before the storage read answers
+ * carry mixpanel's random per-page id. Two scripts creating the id at once on
+ * the first page ever can disagree once; the last write wins from then on.
  */
 function applyStoredAnonymousId() {
   try {
diff --git a/src/popup/helper/login-analytics.ts b/src/popup/helper/login-analytics.ts
new file mode 100644
index 0000000..374c660
--- /dev/null
+++ b/src/popup/helper/login-analytics.ts
@@ -0,0 +1,36 @@
+/**
+ * Login funnel analytics helpers (E-03), used by LoginView.
+ *
+ * `user_logged-in` and `login_failed` carry `source` (where the login started)
+ * and, for a failure, `reason`. The funnel is
+ * save-login-prompt_viewed → save-login-prompt_clicked → user_logged-in
+ * (source save_prompt) → phrase_saved.
+ */
+import type { LoginSource } from "../../common/types/messaging";
+
+export type LoginFailReason = "window_closed" | "google_error" | "server_error";
+
+const LOGIN_SOURCES: readonly LoginSource[] = ["save_prompt", "practice", "popup"];
+
+/**
+ * The `source` query on the login window's route. Anything missing or unknown
+ * is "popup": the login view opened straight from the toolbar popup.
+ */
+export function loginSourceFrom(value: unknown): LoginSource {
+  return LOGIN_SOURCES.includes(value as LoginSource)
+    ? (value as LoginSource)
+    : "popup";
+}
+
+/**
+ * Why the Google step failed. chrome.identity reports a closed or cancelled
+ * consent window as `chrome.runtime.lastError` "The user did not approve
+ * access."; everything else (no token in the redirect, a page that could not
+ * load) is a Google-side error.
+ */
+export function googleFailReason(err: unknown): LoginFailReason {
+  const message = String((err as any)?.message ?? err ?? "");
+  return /did not approve|cancel|closed/i.test(message)
+    ? "window_closed"
+    : "google_error";
+}
diff --git a/src/popup/views/IntroView.vue b/src/popup/views/IntroView.vue
index bbf0ee8..8226c2e 100644
--- a/src/popup/views/IntroView.vue
+++ b/src/popup/views/IntroView.vue
@@ -64,7 +64,7 @@ import { useRouter } from "vue-router";
 const router = useRouter();
 
 function openLogin() {
-  chrome.runtime.sendMessage(new OpenLoginWindowMessage());
+  chrome.runtime.sendMessage(new OpenLoginWindowMessage("popup"));
 }
 
 const slides = [
diff --git a/src/popup/views/LoginView.vue b/src/popup/views/LoginView.vue
index 7918087..6d1972e 100644
--- a/src/popup/views/LoginView.vue
+++ b/src/popup/views/LoginView.vue
@@ -131,6 +131,7 @@
 
 <script setup lang="ts">
 import { computed, onMounted, ref } from "vue";
+import { useRoute } from "vue-router";
 import {
   GetCurrentChromeUserToken,
   LoginStatusResponse,
@@ -145,9 +146,24 @@ import {
   loginWithLastSession,
   isLogin,
 } from "../../plugins/modular-rest";
+import {
+  googleFailReason,
+  loginSourceFrom,
+  type LoginFailReason,
+} from "../helper/login-analytics";
 
 const pending = ref(false);
 
+// Where this login started (E-03): the background opens the login window as
+// `#/login?source=save_prompt|practice|popup`. No router (unit tests) or no
+// query means the toolbar popup.
+const route = useRoute();
+const loginSource = loginSourceFrom(route?.query?.source);
+
+function trackLoginFailed(reason: LoginFailReason) {
+  analytic.track("login_failed", { source: loginSource, reason });
+}
+
 const chromeUserRes = ref<LoginStatusResponse | null>();
 
 // Build-flag gated: dev/agent-only password form. Stable/prod builds omit the
@@ -197,7 +213,14 @@ async function loginWithChrome() {
 
     if (status == "success") {
       await handleTokenLogin(token);
+    } else {
+      trackLoginFailed("server_error");
     }
+  } else {
+    // getAuthToken gave no token: the Chrome profile has no Google account,
+    // or the user dismissed Chrome's consent prompt. Chrome does not tell
+    // these apart here.
+    trackLoginFailed("google_error");
   }
 
   pending.value = false;
@@ -205,18 +228,26 @@ async function loginWithChrome() {
 
 async function loginWithGoogle() {
   pending.value = true;
+  // Which step failed decides the login_failed reason.
+  let step: "google" | "server" = "google";
 
   await authorizeFromGoogleOAuthThroughAuthFlowAPI()
     .then((accessToken) => {
+      step = "server";
       return get(
         joinToBaseUrl(
           `/auth/google/access-token-login?access_token=${accessToken}`
         )
       );
     })
-    .then(({ token }) => handleTokenLogin(token))
+    .then(({ token }) => {
+      // Never store an empty token as a login.
+      if (!token) throw new Error("No token in the login response");
+      return handleTokenLogin(token);
+    })
     .catch((err) => {
       console.log("err", err);
+      trackLoginFailed(step === "google" ? googleFailReason(err) : "server_error");
     })
     .finally(() => {
       pending.value = false;
@@ -252,7 +283,7 @@ async function handleTokenLogin(token: string) {
   await loginWithLastSession();
   // Fired only on an explicit login from this view — session restores on
   // startup do not pass through here.
-  analytic.track("user_logged-in");
+  analytic.track("user_logged-in", { source: loginSource });
 }
 
 function launchWebAuthFlow(authURL) {
@@ -305,11 +336,13 @@ async function loginWithPassword() {
     const token = authentication.getToken;
     if (!token) {
       loginError.value = "Invalid email or password.";
+      trackLoginFailed("server_error");
       return;
     }
     await handleTokenLogin(token);
     passwordValue.value = "";
   } catch (err: any) {
+    trackLoginFailed("server_error");
     // modular-rest rejects with the server response or a network error. We
     // surface a generic message for the credential-mismatch case so we don't
     // leak whether the email exists, and a network-specific message when the
diff --git a/src/stores/marker.ts b/src/stores/marker.ts
index 5ec065f..967c4be 100644
--- a/src/stores/marker.ts
+++ b/src/stores/marker.ts
@@ -273,7 +273,7 @@ export const useMarkerStore = defineStore("marker", {
       const _this = this;
 
       TranslateService.instance
-        .fetchSimpleTranslation(translatingList, this.context)
+        .fetchSimpleTranslation(translatingList, this.context, "word")
         .then((res: string) => {
           _this.sourceLanguage = "auto";
 
diff --git a/src/subtitle/_support-template/components/Subtitle.vue b/src/subtitle/_support-template/components/Subtitle.vue
index 2639cdc..52a5cf8 100644
--- a/src/subtitle/_support-template/components/Subtitle.vue
+++ b/src/subtitle/_support-template/components/Subtitle.vue
@@ -69,10 +69,14 @@
 </template>
 
 <script lang="ts">
-import { defineComponent, PropType, StyleValue } from "vue";
+import { defineComponent, markRaw, PropType, StyleValue } from "vue";
 import { clamp } from "../../../common/helper/math";
 import { getDir, rtls } from "../../../common/helper/text";
 import { TranslateService } from "../../../common/services/translate.service";
+import {
+  createCaptionTranslationGate,
+  type CaptionTranslationGate,
+} from "../../helpers/caption-translation-gate";
 import { Dictionary } from "../../../common/types/general.type";
 import { analytic } from "../../../plugins/mixpanel";
 
@@ -84,6 +88,7 @@ interface DataModel {
   sourceLanguage: string;
   showTranslatedSentence: boolean;
   showWordDetail: boolean;
+  captionGate: CaptionTranslationGate | null;
 }
 
 export default defineComponent({
@@ -102,9 +107,21 @@ export default defineComponent({
       sourceLanguage: "en",
       showTranslatedSentence: false,
       showWordDetail: false,
+      captionGate: null,
     };
   },
 
+  created() {
+    // Not reactive state: the gate only holds a timer and the last caption.
+    this.captionGate = markRaw(
+      createCaptionTranslationGate((text) => this.translateWholeCaption(text))
+    );
+  },
+
+  beforeUnmount() {
+    this.captionGate?.cancel();
+  },
+
   computed: {
     lines() {
       let lines = this.translatedLines.length
@@ -174,13 +191,17 @@ export default defineComponent({
 
         if (!this.showTranslatedSentence || !value || !value.length) return;
 
-        this.translateWholeCaption();
+        // Wait for the caption to settle and send it once (E-06).
+        if (this.captionGate!.request(value.join("\n"))) {
+          this.translatedLines = [];
+        }
       },
     },
 
     showTranslatedSentence(value) {
-      if (!value || this.translatedLines.length) return;
-      this.translateWholeCaption();
+      if (!value) return this.captionGate!.cancel();
+      if (this.translatedLines.length || !this.textList?.length) return;
+      this.captionGate!.sendNow(this.textList.join("\n"));
     },
 
     hoveredWord(value) {
@@ -204,29 +225,29 @@ export default defineComponent({
       return list;
     },
 
-    translateWholeCaption() {
-      // let words = this.getWordList();
-      let lines = this.textList as unknown as Array<string>;
-      let translatingList = [lines.join("\n")];
+    /** Called by the caption gate with the settled caption (E-06). */
+    translateWholeCaption(caption: string) {
+      let translatingList = [caption];
 
       this.translatedLines = [];
 
       TranslateService.instance
-        .fetchSimpleTranslation(translatingList)
+        .fetchSimpleTranslation(translatingList, "", "caption")
         .then((translatedText) => {
           this.sourceLanguage = "auto";
 
           translatingList.forEach((result, i) => {
             this.translatedLines.push(translatedText);
           });
-        });
+        })
+        .catch(() => this.captionGate?.forget(caption));
     },
 
     translateWord(word) {
       let translatingList = [word];
 
       TranslateService.instance
-        .fetchSimpleTranslation(translatingList)
+        .fetchSimpleTranslation(translatingList, "", "word")
         .then((translatedText) => {
           this.sourceLanguage = "auto";
 
diff --git a/src/subtitle/helpers/caption-translation-gate.ts b/src/subtitle/helpers/caption-translation-gate.ts
new file mode 100644
index 0000000..c3ae620
--- /dev/null
+++ b/src/subtitle/helpers/caption-translation-gate.ts
@@ -0,0 +1,71 @@
+/**
+ * Translate each caption once (E-06).
+ *
+ * With "translate whole caption" on, the caption watcher fires on every
+ * `textList` change, and a player can change it several times for one caption
+ * (lines added one by one, a caption that blinks off and back on). Each change
+ * used to send a translation request.
+ *
+ * The gate waits for the caption to settle (`delayMs`, about 150 ms), then
+ * sends it only when the joined text differs from the one whose translation
+ * is on screen (the last one sent). A failed request is forgotten, so the same
+ * caption can be tried again.
+ */
+export const CAPTION_SETTLE_MS = 150;
+
+export interface CaptionTranslationGate {
+  /**
+   * The caption changed to `text`: send it once it has been stable for the
+   * delay, unless its translation is already on screen. Returns true when the
+   * translation on screen belongs to another caption, so the caller should
+   * clear it now instead of showing it under the new text while it settles.
+   */
+  request(text: string): boolean;
+  /** Send `text` now, even if it was sent before (the user turned it on). */
+  sendNow(text: string): void;
+  /** The request for `text` failed: let the same caption be sent again. */
+  forget(text: string): void;
+  /** Drop a waiting request (unmount, translation turned off). */
+  cancel(): void;
+}
+
+export function createCaptionTranslationGate(
+  send: (text: string) => void,
+  delayMs: number = CAPTION_SETTLE_MS
+): CaptionTranslationGate {
+  // The caption whose translation is on screen, or on its way.
+  let lastSent: string | null = null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  const cancel = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+
+  const sendNow = (text: string) => {
+    cancel();
+    lastSent = text;
+    send(text);
+  };
+
+  return {
+    request(text) {
+      cancel();
+      const stale = text !== lastSent;
+      // The caller clears the old translation, so nothing is on screen now.
+      if (stale) lastSent = null;
+      timer = setTimeout(() => {
+        timer = null;
+        if (text !== lastSent) sendNow(text);
+      }, delayMs);
+      return stale;
+    },
+    sendNow,
+    forget(text) {
+      if (lastSent === text) lastSent = null;
+    },
+    cancel() {
+      cancel();
+    },
+  };
+}
diff --git a/src/subtitle/web_netflix/components/Subtitle.vue b/src/subtitle/web_netflix/components/Subtitle.vue
index c426da7..ca5f820 100644
--- a/src/subtitle/web_netflix/components/Subtitle.vue
+++ b/src/subtitle/web_netflix/components/Subtitle.vue
@@ -71,7 +71,7 @@
 </template>
 
 <script lang="ts">
-import { defineComponent, PropType, StyleValue } from "vue";
+import { defineComponent, markRaw, PropType, StyleValue } from "vue";
 import { mapState, mapActions } from "pinia";
 import { useMarkerStore } from "../../../stores/marker";
 import { clamp } from "../../../common/helper/math";
@@ -79,6 +79,10 @@ import { getDir, rtls, cleanText } from "../../../common/helper/text";
 import { TranslateService } from "../../../common/services/translate.service";
 import { log } from "../../../common/helper/log";
 import { LOADING_ICON } from "../../../common/icons/icons";
+import {
+  createCaptionTranslationGate,
+  type CaptionTranslationGate,
+} from "../../helpers/caption-translation-gate";
 
 interface DataModel {
   translatedLines: String[];
@@ -86,6 +90,7 @@ interface DataModel {
   showTranslatedSentence: boolean;
   showWordDetail: boolean;
   isTranslatingWholeCaption: boolean;
+  captionGate: CaptionTranslationGate | null;
 }
 
 export default defineComponent({
@@ -101,9 +106,21 @@ export default defineComponent({
       showTranslatedSentence: false,
       showWordDetail: false,
       isTranslatingWholeCaption: false,
+      captionGate: null,
     };
   },
 
+  created() {
+    // Not reactive state: the gate only holds a timer and the last caption.
+    this.captionGate = markRaw(
+      createCaptionTranslationGate((text) => this.translateWholeCaption(text))
+    );
+  },
+
+  beforeUnmount() {
+    this.captionGate?.cancel();
+  },
+
   computed: {
     ...mapState(useMarkerStore, [
       "selectedPhrase",
@@ -210,7 +227,10 @@ export default defineComponent({
 
         if (!this.showTranslatedSentence || !value || !value.length) return;
 
-        this.translateWholeCaption();
+        // Wait for the caption to settle and send it once (E-06).
+        if (this.captionGate!.request(value.join("\n"))) {
+          this.translatedLines = [];
+        }
       },
     },
 
@@ -218,8 +238,11 @@ export default defineComponent({
       log("showTranslatedSentence", value);
 
       if (value == true) {
-        this.translateWholeCaption();
+        if (this.textList?.length) {
+          this.captionGate!.sendNow(this.textList.join("\n"));
+        }
       } else {
+        this.captionGate!.cancel();
         this.translatedLines = [];
         this.clear();
       }
@@ -241,22 +264,22 @@ export default defineComponent({
       return list;
     },
 
-    translateWholeCaption() {
-      // let words = this.getWordList();
-      let lines = this.textList as unknown as Array<string>;
-      let translatingList = [lines.join("\n")];
+    /** Called by the caption gate with the settled caption (E-06). */
+    translateWholeCaption(caption: string) {
+      let translatingList = [caption];
 
       this.translatedLines = [];
 
       this.isTranslatingWholeCaption = true;
 
       TranslateService.instance
-        .fetchSimpleTranslation(translatingList)
+        .fetchSimpleTranslation(translatingList, "", "caption")
         .then((translationResult) => {
           translatingList.forEach((result, i) => {
             this.translatedLines.push(translationResult);
           });
         })
+        .catch(() => this.captionGate?.forget(caption))
         .finally(() => {
           this.isTranslatingWholeCaption = false;
         });
diff --git a/tests/caption-translation-gate.test.ts b/tests/caption-translation-gate.test.ts
new file mode 100644
index 0000000..28f5622
--- /dev/null
+++ b/tests/caption-translation-gate.test.ts
@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  CAPTION_SETTLE_MS,
+  createCaptionTranslationGate,
+} from "../src/subtitle/helpers/caption-translation-gate";
+
+// E-06: with "translate whole caption" on, each real caption change sends one
+// request, after the caption settles.
+describe("caption translation gate", () => {
+  let send: ReturnType<typeof vi.fn>;
+  let gate: ReturnType<typeof createCaptionTranslationGate>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    send = vi.fn();
+    gate = createCaptionTranslationGate(send);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("waits for the caption to settle, then sends it once", () => {
+    gate.request("Hello");
+    gate.request("Hello\nworld");
+    vi.advanceTimersByTime(CAPTION_SETTLE_MS - 1);
+    expect(send).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(1);
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(send).toHaveBeenCalledWith("Hello\nworld");
+  });
+
+  it("skips a caption equal to the last one sent", () => {
+    gate.request("Hello");
+    vi.runAllTimers();
+    // The caption blinks off and comes back: no new request, nothing stale.
+    expect(gate.request("Hello")).toBe(false);
+    vi.runAllTimers();
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+
+  it("reports a new caption as stale and sends it", () => {
+    gate.request("Hello");
+    vi.runAllTimers();
+    expect(gate.request("Bye")).toBe(true);
+    vi.runAllTimers();
+    expect(send.mock.calls).toEqual([["Hello"], ["Bye"]]);
+  });
+
+  it("sends the first caption again after A → B → A (its translation was cleared)", () => {
+    gate.request("A");
+    vi.runAllTimers();
+    gate.request("B");
+    expect(gate.request("A")).toBe(true);
+    vi.runAllTimers();
+    // B never settled, so only A is sent again.
+    expect(send.mock.calls).toEqual([["A"], ["A"]]);
+  });
+
+  it("sendNow sends at once, even the same caption", () => {
+    gate.request("Hello");
+    vi.runAllTimers();
+    gate.sendNow("Hello");
+    expect(send).toHaveBeenCalledTimes(2);
+  });
+
+  it("forget lets a failed caption be sent again", () => {
+    gate.request("Hello");
+    vi.runAllTimers();
+    gate.forget("Hello");
+    gate.request("Hello");
+    vi.runAllTimers();
+    expect(send).toHaveBeenCalledTimes(2);
+  });
+
+  it("cancel drops a waiting request", () => {
+    gate.request("Hello");
+    gate.cancel();
+    vi.runAllTimers();
+    expect(send).not.toHaveBeenCalled();
+  });
+});
diff --git a/tests/install-tracking.test.ts b/tests/install-tracking.test.ts
new file mode 100644
index 0000000..f49445d
--- /dev/null
+++ b/tests/install-tracking.test.ts
@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+import {
+  handleInstalled,
+  welcomeUrl,
+} from "../src/common/helper/install-tracking";
+import { ANON_ID_KEY } from "../src/common/helper/install-id";
+
+// E-02: chrome.runtime.onInstalled tracks extension_installed /
+// extension_updated on the install id, and opens the welcome page on install.
+
+const UUID_V4 =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+function memoryChromeStorage() {
+  const mem: Record<string, any> = {};
+  vi.mocked(chrome.storage.local.get).mockImplementation(((
+    key: string,
+    cb: (d: any) => void
+  ) => cb(key in mem ? { [key]: mem[key] } : {})) as any);
+  vi.mocked(chrome.storage.local.set).mockImplementation(((
+    obj: Record<string, any>,
+    cb?: () => void
+  ) => {
+    Object.assign(mem, obj);
+    cb?.();
+  }) as any);
+  return mem;
+}
+
+/** Decode the events posted to the mixpanel /track endpoint. */
+function sentEvents(fetchMock: ReturnType<typeof vi.fn>) {
+  return fetchMock.mock.calls.map(([url, init]) => {
+    const data = new URLSearchParams(init.body).get("data")!;
+    const bin = atob(data);
+    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0));
+    return { url, ...JSON.parse(new TextDecoder().decode(bytes)) };
+  });
+}
+
+describe("handleInstalled (background)", () => {
+  let mem: Record<string, any>;
+  let fetchMock: ReturnType<typeof vi.fn>;
+  let manifest: Record<string, any>;
+  const tabsCreate = vi.fn(async (_: any) => ({}));
+
+  beforeEach(() => {
+    mem = memoryChromeStorage();
+    manifest = { version: "1.18.0", update_url: "https://clients2.google.com/" };
+    (chrome.runtime as any).getManifest = () => manifest;
+    (chrome.tabs as any).create = tabsCreate;
+    tabsCreate.mockClear();
+    fetchMock = vi.fn(async () => new Response("1"));
+    vi.stubGlobal("fetch", fetchMock);
+    vi.stubEnv("MIXPANEL_PROJECT_TOKEN", "test-token");
+    vi.stubEnv("MIXPANEL_API_HOST", "https://proxy.test/");
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.unstubAllEnvs();
+  });
+
+  it("on install: creates the install id, opens the welcome page, tracks extension_installed", async () => {
+    await handleInstalled({ reason: "install" } as any);
+
+    const id = mem[ANON_ID_KEY];
+    expect(id).toMatch(UUID_V4);
+
+    expect(tabsCreate).toHaveBeenCalledWith({
+      url: `https://subturtle.app/?install_id=${id}&utm_source=extension&utm_medium=install`,
+    });
+
+    const [e] = sentEvents(fetchMock);
+    expect(e.url).toBe("https://proxy.test/track/?ip=1");
+    expect(e.event).toBe("extension_installed");
+    expect(e.properties).toMatchObject({
+      token: "test-token",
+      distinct_id: id,
+      $device_id: id,
+      app: "chrome-extension",
+      version: "1.18.0",
+      reason: "install",
+    });
+  });
+
+  it("reuses an install id that already exists", async () => {
+    mem[ANON_ID_KEY] = "existing-id";
+    await handleInstalled({ reason: "install" } as any);
+    expect(mem[ANON_ID_KEY]).toBe("existing-id");
+    expect(sentEvents(fetchMock)[0].properties.distinct_id).toBe("existing-id");
+  });
+
+  it("on update: tracks extension_updated with previous_version and opens nothing", async () => {
+    mem[ANON_ID_KEY] = "existing-id";
+    await handleInstalled({ reason: "update", previousVersion: "1.17.0" } as any);
+
+    expect(tabsCreate).not.toHaveBeenCalled();
+    const [e] = sentEvents(fetchMock);
+    expect(e.event).toBe("extension_updated");
+    expect(e.properties).toMatchObject({
+      distinct_id: "existing-id",
+      previous_version: "1.17.0",
+      version: "1.18.0",
+    });
+  });
+
+  it("ignores a Chrome update", async () => {
+    await handleInstalled({ reason: "chrome_update" } as any);
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(tabsCreate).not.toHaveBeenCalled();
+  });
+
+  it("an unpacked build still tracks the install but opens no tab", async () => {
+    delete manifest.update_url;
+    await handleInstalled({ reason: "install" } as any);
+    expect(tabsCreate).not.toHaveBeenCalled();
+    expect(sentEvents(fetchMock)[0].event).toBe("extension_installed");
+  });
+
+  it("a failed analytics request does not throw", async () => {
+    fetchMock.mockRejectedValue(new Error("offline"));
+    await expect(handleInstalled({ reason: "install" } as any)).resolves.toBeUndefined();
+    expect(tabsCreate).toHaveBeenCalled();
+  });
+
+  it("builds the welcome URL with encoded params", () => {
+    expect(welcomeUrl("a b")).toBe(
+      "https://subturtle.app/?install_id=a+b&utm_source=extension&utm_medium=install"
+    );
+  });
+});
diff --git a/tests/login-analytics.test.ts b/tests/login-analytics.test.ts
new file mode 100644
index 0000000..9d18849
--- /dev/null
+++ b/tests/login-analytics.test.ts
@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mount, flushPromises, type VueWrapper } from "@vue/test-utils";
+import { createTestingPinia } from "@pinia/testing";
+
+// E-03: user_logged-in carries `source`, and a failed login sends
+// login_failed with `source` and `reason`.
+
+const { loginMock, tokenRef, getMock, route } = vi.hoisted(() => {
+  process.env.ENABLE_PASSWORD_AUTH = "true";
+  return {
+    loginMock: vi.fn(),
+    tokenRef: { current: null as string | null },
+    getMock: vi.fn(),
+    route: { current: { query: {} as Record<string, unknown> } },
+  };
+});
+
+vi.mock("vue-router", () => ({ useRoute: () => route.current }));
+vi.mock("../src/plugins/modular-rest", async () => {
+  const { ref } = await import("vue");
+  return {
+    authentication: {
+      login: loginMock,
+      get getToken() {
+        return tokenRef.current;
+      },
+    },
+    loginWithLastSession: vi.fn().mockResolvedValue(undefined),
+    isLogin: ref(false),
+  };
+});
+vi.mock("../src/popup/helper/http", () => ({ get: getMock, post: vi.fn() }));
+
+import LoginView from "../src/popup/views/LoginView.vue";
+import {
+  googleFailReason,
+  loginSourceFrom,
+} from "../src/popup/helper/login-analytics";
+import { analytic } from "../src/plugins/mixpanel";
+
+const track = vi.mocked(analytic.track);
+const eventsNamed = (name: string) =>
+  track.mock.calls.filter(([e]) => e === name).map(([, p]) => p);
+
+describe("login analytics helpers", () => {
+  it("reads a known source and falls back to popup", () => {
+    expect(loginSourceFrom("save_prompt")).toBe("save_prompt");
+    expect(loginSourceFrom("practice")).toBe("practice");
+    expect(loginSourceFrom(undefined)).toBe("popup");
+    expect(loginSourceFrom("evil")).toBe("popup");
+    expect(loginSourceFrom(["save_prompt"])).toBe("popup");
+  });
+
+  it("maps a closed Google window to window_closed, the rest to google_error", () => {
+    expect(googleFailReason({ message: "The user did not approve access." })).toBe(
+      "window_closed"
+    );
+    expect(googleFailReason(new Error("No access_token found"))).toBe(
+      "google_error"
+    );
+    expect(googleFailReason(undefined)).toBe("google_error");
+  });
+});
+
+describe("LoginView login events", () => {
+  let wrapper: VueWrapper | null = null;
+  let authFlow: (cb: (url?: string) => void) => void;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tokenRef.current = null;
+    route.current = { query: { source: "save_prompt" } };
+    (chrome as any).identity = {
+      getRedirectURL: () => "https://id.chromiumapp.org/",
+      launchWebAuthFlow: (_: unknown, cb: (url?: string) => void) =>
+        authFlow(cb),
+    };
+    authFlow = (cb) => cb("https://id.chromiumapp.org/#access_token=g-token");
+  });
+
+  afterEach(() => {
+    wrapper?.unmount();
+    wrapper = null;
+    (chrome.runtime as any).lastError = undefined;
+  });
+
+  async function mountView() {
+    wrapper = mount(LoginView, {
+      global: { plugins: [createTestingPinia({ createSpy: vi.fn })] },
+    });
+    await flushPromises();
+    return wrapper;
+  }
+
+  const googleButton = (w: VueWrapper) =>
+    w.findAll("button").find((b) => b.text().includes("Google Account"))!;
+
+  async function submitPassword(w: VueWrapper) {
+    await w.find('[data-testid="open-password-form"]').trigger("click");
+    await w.find('[data-testid="password-email"]').setValue("a@b.co");
+    await w.find('[data-testid="password-value"]').setValue("password123");
+    await w.find('[data-testid="password-form"]').trigger("submit");
+    await flushPromises();
+  }
+
+  it("user_logged-in carries the source from the route", async () => {
+    getMock.mockResolvedValue({ status: "success", token: "jwt" });
+    const w = await mountView();
+    await googleButton(w).trigger("click");
+    await flushPromises();
+
+    expect(eventsNamed("user_logged-in")).toEqual([{ source: "save_prompt" }]);
+    expect(eventsNamed("login_failed")).toEqual([]);
+  });
+
+  it("no source on the route counts as popup", async () => {
+    route.current = { query: {} };
+    loginMock.mockImplementation(async () => {
+      tokenRef.current = "jwt";
+    });
+    const w = await mountView();
+    await submitPassword(w);
+
+    expect(eventsNamed("user_logged-in")).toEqual([{ source: "popup" }]);
+  });
+
+  it("closing the Google window sends login_failed window_closed", async () => {
+    authFlow = (cb) => {
+      (chrome.runtime as any).lastError = {
+        message: "The user did not approve access.",
+      };
+      cb(undefined);
+    };
+    const w = await mountView();
+    await googleButton(w).trigger("click");
+    await flushPromises();
+
+    expect(eventsNamed("login_failed")).toEqual([
+      { source: "save_prompt", reason: "window_closed" },
+    ]);
+    expect(getMock).not.toHaveBeenCalled();
+  });
+
+  it("a server error after Google sends login_failed server_error", async () => {
+    route.current = { query: { source: "practice" } };
+    getMock.mockRejectedValue(new Error("HTTP error! status: 500"));
+    const w = await mountView();
+    await googleButton(w).trigger("click");
+    await flushPromises();
+
+    expect(eventsNamed("login_failed")).toEqual([
+      { source: "practice", reason: "server_error" },
+    ]);
+    expect(eventsNamed("user_logged-in")).toEqual([]);
+  });
+
+  it("a server reply with no token is a failure, not a login", async () => {
+    getMock.mockResolvedValue({ status: "error" });
+    const w = await mountView();
+    await googleButton(w).trigger("click");
+    await flushPromises();
+
+    expect(eventsNamed("login_failed")).toEqual([
+      { source: "save_prompt", reason: "server_error" },
+    ]);
+    expect(eventsNamed("user_logged-in")).toEqual([]);
+  });
+
+  it("a rejected password login sends login_failed server_error", async () => {
+    loginMock.mockRejectedValue({ status: false, error: "Wrong creds" });
+    const w = await mountView();
+    await submitPassword(w);
+
+    expect(eventsNamed("login_failed")).toEqual([
+      { source: "save_prompt", reason: "server_error" },
+    ]);
+  });
+});
diff --git a/tests/save-login-prompt.test.ts b/tests/save-login-prompt.test.ts
new file mode 100644
index 0000000..a49224f
--- /dev/null
+++ b/tests/save-login-prompt.test.ts
@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { mount, flushPromises } from "@vue/test-utils";
+import { createTestingPinia } from "@pinia/testing";
+import { reactive } from "vue";
+import { encodeRouteParams } from "../src/console-crane/route-params";
+
+// E-03: the "Login to save this phrase" button on the word card sends
+// save-login-prompt_viewed once per word view and save-login-prompt_clicked,
+// and opens the login window with source "save_prompt".
+
+const route = vi.hoisted(() => ({ current: null as any }));
+vi.mock("vue-router", () => ({ useRoute: () => route.current }));
+
+const { loginRef } = vi.hoisted(() => ({ loginRef: { current: null as any } }));
+vi.mock("../src/plugins/modular-rest", async () => {
+  const { ref } = await import("vue");
+  loginRef.current = ref(false);
+  return { isLogin: loginRef.current };
+});
+
+vi.mock("../src/console-crane/components/SaveWordSectionV2.vue", () => ({
+  default: { name: "SaveWordSectionV2", template: "<div />" },
+}));
+vi.mock("pilotui", () => ({
+  Button: { name: "PilotButton", template: "<button />" },
+}));
+vi.mock("pilotui/elements", () => ({
+  IconButton: { name: "PilotIconButton", template: "<span />" },
+}));
+vi.mock("../src/common/services/translate.service", () => ({
+  TranslateService: {
+    instance: {
+      fetchDetailedTranslation: vi.fn(),
+      fetchTranslationAdvice: vi.fn(),
+      languageTitle: "Persian",
+      targetLanguage: "fa",
+    },
+  },
+}));
+vi.mock("../src/common/services/phrase.service", () => ({
+  findSavedPhrase: vi.fn(),
+}));
+
+import WordDetail from "../src/console-crane/modules/word-detail/index.vue";
+import { TranslateService } from "../src/common/services/translate.service";
+import { findSavedPhrase } from "../src/common/services/phrase.service";
+import { analytic } from "../src/plugins/mixpanel";
+import { OpenLoginWindowMessage } from "../src/common/types/messaging";
+
+const fetchDetailed = vi.mocked(
+  TranslateService.instance.fetchDetailedTranslation
+);
+const track = vi.mocked(analytic.track);
+
+const count = (event: string) =>
+  track.mock.calls.filter(([e]) => e === event).length;
+
+function showWord(word: string) {
+  route.current.name = "word-detail";
+  route.current.params.data = encodeRouteParams({ word, context: "" });
+}
+
+function mountCard() {
+  return mount(WordDetail, {
+    global: {
+      plugins: [createTestingPinia({ createSpy: vi.fn })],
+      provide: { frameSize: { width: 400, height: 600 } },
+    },
+  });
+}
+
+const loginButton = (w: ReturnType<typeof mountCard>) =>
+  w.findAll("button").find((b) => b.text().includes("Login to save"));
+
+describe("save-login prompt on the word card (E-03)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    loginRef.current.value = false;
+    vi.mocked(findSavedPhrase).mockResolvedValue(null);
+    fetchDetailed.mockImplementation(async (word: string) => ({
+      phrase: word,
+      context: "",
+      translation: { phrase: `fa:${word}`, context: "" },
+      linguistic_data: { isValid: true, definition: "x" },
+      chunks: [],
+    }) as any);
+    route.current = reactive({ name: "", params: { data: "" } });
+    showWord("had to");
+  });
+
+  it("sends save-login-prompt_viewed once when the button shows", async () => {
+    const w = mountCard();
+    await flushPromises();
+
+    expect(loginButton(w)).toBeDefined();
+    expect(count("save-login-prompt_viewed")).toBe(1);
+
+    // A re-render of the same word view does not send it again.
+    await w.vm.$forceUpdate();
+    await flushPromises();
+    expect(count("save-login-prompt_viewed")).toBe(1);
+    w.unmount();
+  });
+
+  it("sends it again for a new word", async () => {
+    const w = mountCard();
+    await flushPromises();
+    showWord("give up");
+    await flushPromises();
+
+    expect(fetchDetailed).toHaveBeenCalledTimes(2);
+    expect(count("save-login-prompt_viewed")).toBe(2);
+    w.unmount();
+  });
+
+  it("does not send it to a logged-in user", async () => {
+    loginRef.current.value = true;
+    const w = mountCard();
+    await flushPromises();
+
+    expect(loginButton(w)).toBeUndefined();
+    expect(count("save-login-prompt_viewed")).toBe(0);
+    w.unmount();
+  });
+
+  it("click: sends save-login-prompt_clicked and opens login with source save_prompt", async () => {
+    const w = mountCard();
+    await flushPromises();
+    await loginButton(w)!.trigger("click");
+
+    expect(count("save-login-prompt_clicked")).toBe(1);
+    const send = chrome.runtime.sendMessage as ReturnType<typeof vi.fn>;
+    const open = send.mock.calls.find(([m]) => OpenLoginWindowMessage.is(m));
+    expect(open?.[0].source).toBe("save_prompt");
+    w.unmount();
+  });
+});
diff --git a/tests/translate-analytics-args.test.ts b/tests/translate-analytics-args.test.ts
new file mode 100644
index 0000000..567fb10
--- /dev/null
+++ b/tests/translate-analytics-args.test.ts
@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { setActivePinia, createPinia } from "pinia";
+
+// E-01 / E-05: translation calls send the install's analytics id as
+// `deviceId` and what asked for them as `trigger`.
+const auth = vi.hoisted(() => ({
+  user: null as { id: string } | null,
+  isLogin: true,
+  getToken: "anon-token" as string | null,
+  loginAsAnonymous: vi.fn(),
+}));
+
+vi.mock("@modular-rest/client", () => ({
+  functionProvider: { run: vi.fn() },
+  authentication: auth,
+}));
+
+import { TranslateService } from "../src/common/services/translate.service";
+import { useSettingsStore } from "../src/common/store/settings";
+import { ANON_ID_KEY, getInstallId } from "../src/common/helper/install-id";
+import { functionProvider } from "@modular-rest/client";
+
+const runMock = functionProvider.run as unknown as ReturnType<typeof vi.fn>;
+const UUID_V4 =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+/** An in-memory chrome.storage.local, since the shared shim stores nothing. */
+function memoryChromeStorage() {
+  const mem: Record<string, any> = {};
+  vi.mocked(chrome.storage.local.get).mockImplementation(((
+    key: string,
+    cb: (d: any) => void
+  ) => setTimeout(() => cb(key in mem ? { [key]: mem[key] } : {}), 0)) as any);
+  vi.mocked(chrome.storage.local.set).mockImplementation(((
+    obj: Record<string, any>,
+    cb?: () => void
+  ) => {
+    Object.assign(mem, obj);
+    setTimeout(() => cb?.(), 0);
+  }) as any);
+  return mem;
+}
+
+function lastArgs() {
+  return runMock.mock.calls.at(-1)![0].args;
+}
+
+describe("getInstallId", () => {
+  let mem: Record<string, any>;
+  beforeEach(() => {
+    mem = memoryChromeStorage();
+  });
+
+  it("returns the stored id", async () => {
+    mem[ANON_ID_KEY] = "install-1";
+    expect(await getInstallId()).toBe("install-1");
+  });
+
+  it("creates and stores one id when there is none, even for parallel callers", async () => {
+    const [a, b] = await Promise.all([getInstallId(), getInstallId()]);
+    expect(a).toMatch(UUID_V4);
+    expect(b).toBe(a);
+    expect(mem[ANON_ID_KEY]).toBe(a);
+  });
+
+  it("follows a new id written later (logout rotates it)", async () => {
+    mem[ANON_ID_KEY] = "before";
+    expect(await getInstallId()).toBe("before");
+    mem[ANON_ID_KEY] = "after";
+    expect(await getInstallId()).toBe("after");
+  });
+
+  it("resolves undefined without an extension context", async () => {
+    vi.mocked(chrome.storage.local.get).mockImplementation((() => {
+      throw new Error("Extension context invalidated.");
+    }) as any);
+    expect(await getInstallId()).toBeUndefined();
+  });
+});
+
+describe("TranslateService analytics args", () => {
+  let mem: Record<string, any>;
+
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    useSettingsStore().language = "en";
+    (TranslateService.instance as any).translationCache = {};
+    runMock.mockReset();
+    runMock.mockResolvedValue("translated");
+    mem = memoryChromeStorage();
+    mem[ANON_ID_KEY] = "install-1";
+    auth.user = null;
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("sends deviceId and trigger with a simple translation", async () => {
+    await TranslateService.instance.fetchSimpleTranslation(
+      ["a caption"],
+      "",
+      "caption"
+    );
+    expect(runMock.mock.calls.at(-1)![0].name).toBe("translateWithContext");
+    expect(lastArgs()).toMatchObject({
+      translationType: "simple",
+      deviceId: "install-1",
+      trigger: "caption",
+    });
+  });
+
+  it("keeps sending userId for a signed-in user", async () => {
+    auth.user = { id: "user-1" };
+    await TranslateService.instance.fetchSimpleTranslation("hi", "", "word");
+    expect(lastArgs()).toMatchObject({
+      userId: "user-1",
+      deviceId: "install-1",
+      trigger: "word",
+    });
+  });
+
+  it("sends trigger 'detail' by default with a detailed translation", async () => {
+    runMock.mockResolvedValue({ chunks: [] });
+    await TranslateService.instance.fetchDetailedTranslation("hello", "ctx");
+    expect(lastArgs()).toMatchObject({
+      translationType: "detailed",
+      deviceId: "install-1",
+      trigger: "detail",
+    });
+  });
+
+  it("waits for a first-run id instead of sending an empty one", async () => {
+    delete mem[ANON_ID_KEY];
+    await TranslateService.instance.fetchSimpleTranslation(
+      "x",
+      "",
+      "selection"
+    );
+    expect(lastArgs().deviceId).toMatch(UUID_V4);
+    expect(lastArgs().deviceId).toBe(mem[ANON_ID_KEY]);
+  });
+
+  it("sends no deviceId key when there is no extension context", async () => {
+    vi.mocked(chrome.storage.local.get).mockImplementation((() => {
+      throw new Error("Extension context invalidated.");
+    }) as any);
+    await TranslateService.instance.fetchSimpleTranslation("y", "", "word");
+    expect(lastArgs()).not.toHaveProperty("deviceId");
+  });
+
+  it("sends deviceId with translationAdvice", async () => {
+    runMock.mockResolvedValue({ type: "reply", text: "ok" });
+    await TranslateService.instance.fetchTranslationAdvice({
+      phrase: "p",
+      context: "c",
+      message: "m",
+    });
+    expect(runMock.mock.calls.at(-1)![0].name).toBe("translationAdvice");
+    expect(lastArgs().deviceId).toBe("install-1");
+  });
+});
diff --git a/tests/translate.service.test.ts b/tests/translate.service.test.ts
index 440721a..0b76e39 100644
--- a/tests/translate.service.test.ts
+++ b/tests/translate.service.test.ts
@@ -41,6 +41,7 @@ describe("TranslateService cache", () => {
     // The singleton is shared across imports; reset the private cache so
     // tests don't leak state into each other.
     (TranslateService.instance as any).translationCache = {};
+    (TranslateService.instance as any).inFlight = new Map();
     svc = TranslateService.instance;
 
     runMock.mockReset();
@@ -116,6 +117,74 @@ describe("TranslateService cache", () => {
     expect(result).toBe("ok");
     expect(runMock).toHaveBeenCalledTimes(2);
   });
+
+  // E-04: identical calls made while the first one is on its way share it.
+  describe("in-flight sharing", () => {
+    function deferred<T>() {
+      let resolve!: (v: T) => void;
+      let reject!: (e: unknown) => void;
+      const promise = new Promise<T>((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return { promise, resolve, reject };
+    }
+
+    it("sends one request for two identical calls in flight", async () => {
+      const d = deferred<string>();
+      runMock.mockReturnValueOnce(d.promise);
+
+      const a = svc.fetchSimpleTranslation("hello", "ctx");
+      const b = svc.fetchSimpleTranslation("hello", "ctx");
+      await vi.waitFor(() => expect(runMock).toHaveBeenCalledTimes(1));
+      d.resolve("shared");
+
+      expect(await a).toBe("shared");
+      expect(await b).toBe("shared");
+      expect(runMock).toHaveBeenCalledTimes(1);
+      expect((svc as any).inFlight.size).toBe(0);
+    });
+
+    it("shares detailed requests too", async () => {
+      const d = deferred<any>();
+      runMock.mockReturnValueOnce(d.promise);
+
+      const a = svc.fetchDetailedTranslation("hello", "ctx");
+      const b = svc.fetchDetailedTranslation("hello", "ctx");
+      await vi.waitFor(() => expect(runMock).toHaveBeenCalledTimes(1));
+      d.resolve({ translation: { phrase: "x" } });
+
+      expect(await b).toBe(await a);
+      expect(runMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not share different keys", async () => {
+      await Promise.all([
+        svc.fetchSimpleTranslation("hello", "ctxA"),
+        svc.fetchSimpleTranslation("hello", "ctxB"),
+      ]);
+      expect(runMock).toHaveBeenCalledTimes(2);
+    });
+
+    it("a failure reaches every waiting caller and is not kept", async () => {
+      const d = deferred<string>();
+      runMock.mockReturnValueOnce(d.promise);
+
+      const a = svc.fetchSimpleTranslation("hello", "ctx");
+      const b = svc.fetchSimpleTranslation("hello", "ctx");
+      await vi.waitFor(() => expect(runMock).toHaveBeenCalledTimes(1));
+      d.reject(new Error("network"));
+
+      await expect(a).rejects.toThrow("network");
+      await expect(b).rejects.toThrow("network");
+      expect((svc as any).inFlight.size).toBe(0);
+
+      // The next call sends a new request.
+      runMock.mockResolvedValue("ok");
+      expect(await svc.fetchSimpleTranslation("hello", "ctx")).toBe("ok");
+      expect(runMock).toHaveBeenCalledTimes(2);
+    });
+  });
 });
 
 // Regression net for the "Translation failed / User not found" report: a stale
diff --git a/tests/word-detail-back-nav.test.ts b/tests/word-detail-back-nav.test.ts
index 2769331..a86100a 100644
--- a/tests/word-detail-back-nav.test.ts
+++ b/tests/word-detail-back-nav.test.ts
@@ -134,7 +134,7 @@ describe("word card ↔ flashcard preview (Back)", () => {
 
     expect(viewedCount()).toBe(2);
     expect(fetchDetailed).toHaveBeenCalledTimes(2);
-    expect(fetchDetailed).toHaveBeenLastCalledWith("give up", "");
+    expect(fetchDetailed).toHaveBeenLastCalledWith("give up", "", "detail");
     w.unmount();
   });
 });