@echomem/mcp 1.4.20 → 1.4.21

package/dist/crypto.js

@@ -95,6 +95,10 @@ export async function decrypt(ciphertext, key) {
     const plainBuffer = await subtle.decrypt({ name: ALGORITHM, iv }, key, data);
     return new TextDecoder().decode(plainBuffer);
 }
+/** Create a server-verifiable token for a newly configured encryption key. */
+export async function createVerification(key) {
+    return encrypt(VERIFICATION_PLAINTEXT, key);
+}
 /** Verify a key against a stored verification token (current + legacy plaintexts). */
 export async function verifyKey(key, token) {
     try {

package/dist/encryption.js

@@ -1,4 +1,5 @@
-import { deriveKey, exportKeyToBase64, importKeyFromBase64, decrypt, verifyKey, saltFromBase64 } from "./crypto.js";
+import { createVerification, deriveKey, exportKeyToBase64, generateSalt, importKeyFromBase64, decrypt, saltFromBase64, saltToBase64, verifyKey, } from "./crypto.js";
+const DEFAULT_KEY_ITERATIONS = 600_000;
 /** GET the account's encryption status from the EchoMem backend using the bridge's authed client. */
 export async function fetchEncryptionConfig(axios) {
     // Bounded: this is on the startup/tool-listing path; an unbounded call on a flaky network would hang
@@ -21,11 +22,22 @@ export async function deriveAndVerifyKey(passphrase, config) {
     if (!config.enabled || !config.salt || !config.verification)
         return null;
     const salt = saltFromBase64(config.salt);
-    const key = await deriveKey(passphrase, salt, config.iterations ?? 600_000);
+    const key = await deriveKey(passphrase, salt, config.iterations ?? DEFAULT_KEY_ITERATIONS);
     if (!(await verifyKey(key, config.verification)))
         return null;
     return exportKeyToBase64(key);
 }
+/** Create a fresh account encryption config locally. The passphrase/key never leaves the device. */
+export async function setupNewEncryptionKey(passphrase, iterations = DEFAULT_KEY_ITERATIONS) {
+    const salt = generateSalt();
+    const key = await deriveKey(passphrase, salt, iterations);
+    return {
+        keyBase64: await exportKeyToBase64(key),
+        saltBase64: saltToBase64(salt),
+        verification: await createVerification(key),
+        iterations,
+    };
+}
 /** Verify an already-exported base64 key against the server's verification token. */
 export async function verifyKeyB64(keyBase64, config) {
     if (!config.enabled || !config.verification)

package/dist/index.js

@@ -10,7 +10,7 @@ import { EventLogger, hashText } from "./events.js";
 import { buildReportText } from "./report.js";
 import { contextHealthMarkdown, recomposeCapsuleMarkdown } from "./hud/api.js";
 import { createHash, randomUUID } from "node:crypto";
-import { fetchEncryptionConfig, decryptMemoryFields } from "./encryption.js";
+import { fetchEncryptionConfig, decryptMemoryFields, verifyKeyB64, } from "./encryption.js";
 import { runCli } from "./setup.js";
 import { MCP_PACKAGE_VERSION, MCP_SERVER_INSTRUCTIONS } from "./package-metadata.js";
 import { clearBillingAlert, writeBillingAlert } from "./billing-alert.js";
@@ -23,6 +23,9 @@ class NoTokenError extends Error {
 /** Thrown when an encrypted account has no usable key — the model gets an unlock nudge, never ciphertext. */
 class LockedError extends Error {
 }
+/** Thrown when the bridge cannot prove whether the account is encrypted. */
+class EncryptionStatusUnavailableError extends Error {
+}
 function stringifyErrorValue(value) {
     if (value == null) {
         return "";
@@ -121,7 +124,7 @@ function formatUpgradeRequiredResult(error) {
         pricingUrl,
     });
     return [
-        "ACTION REQUIRED: tell the user to start a 7-day Pro trial or choose a subscription at this exact URL:",
+        "ACTION REQUIRED: tell the user to start a 14-day Pro trial or choose a subscription at this exact URL:",
         pricingUrl,
         "When replying, include the exact URL above. Do not reply only with \"connect\" or \"upgrade\".",
         "",
@@ -130,6 +133,15 @@ function formatUpgradeRequiredResult(error) {
         code ? `Reason: ${code}.` : "",
     ].filter(Boolean).join("\n");
 }
+function formatReconnectRequiredResult(error) {
+    if (!axios.isAxiosError(error) || error.response?.status !== 401)
+        return null;
+    return [
+        "🔌 EchoMem's saved login is no longer accepted (Unauthorized, HTTP 401).",
+        "Action required from the user: run `echomem-mcp login` in a terminal to reconnect this device, then retry this action.",
+        "No editor restart is needed. Keep all credentials out of chat.",
+    ].join("\n");
+}
 /** Map a thrown error to the telemetry error_kind taxonomy. */
 function classifyError(error) {
     if (error instanceof NoTokenError)
@@ -564,8 +576,8 @@ class EchoMemApiClient {
         if (!this.encConfigPromise) {
             this.encConfigPromise = fetchEncryptionConfig(this.axios).catch((error) => {
                 this.encConfigPromise = null; // allow retry next call
-                console.error(`[encryption] config fetch failed: ${describeError(error)} — proceeding as unencrypted`);
-                return { enabled: false };
+                console.error(`[encryption] config fetch failed: ${describeError(error)} — refusing memory access`);
+                throw new EncryptionStatusUnavailableError("EchoMem could not verify the account encryption state");
             });
         }
         return this.encConfigPromise;
@@ -576,18 +588,20 @@ class EchoMemApiClient {
      * handing the model ciphertext. For unencrypted accounts it returns `{ enabled: false }`.
      */
     async encState() {
-        // A stored key ONLY exists because the user unlocked an ENCRYPTED vault, so treat it as
-        // authoritative: a flaky/failed `/account/encryption` fetch (which defaults to enabled:false) must
-        // NOT downgrade an unlocked encrypted account to plaintext — that causes a 422 on save and leaks
-        // ciphertext on read. So if we hold a usable key, we're encrypted-and-unlocked, period.
-        const key = this.store.getKey();
-        if (key)
-            return { enabled: true, key };
-        // No usable key: consult the server to tell "unencrypted" apart from "encrypted but locked/expired".
         const cfg = await this.getEncryptionConfig();
-        if (cfg.enabled)
+        if (!cfg.enabled)
+            return { enabled: false };
+        const key = this.store.getKey();
+        if (!key)
             throw new LockedError("EchoMem vault locked");
-        return { enabled: false };
+        if (!(await verifyKeyB64(key, cfg))) {
+            // A file-backed stale key can be removed safely; environment-provided
+            // keys remain under the caller's control and are ignored until corrected.
+            if (!process.env.ECHO_ENCRYPTION_KEY)
+                this.store.clearKey();
+            throw new LockedError("EchoMem vault key is invalid");
+        }
+        return { enabled: true, key };
     }
     pruneDeleteConfirmations(now = Date.now()) {
         for (const [memoryId, confirmation] of this.deleteConfirmations) {
@@ -608,13 +622,6 @@ class EchoMemApiClient {
         }
         return this.whoamiCache;
     }
-    cleanMemoryDescription(desc) {
-        if (!desc)
-            return "";
-        // The tuned snapshot wraps text as "Here is a memory: …Content: <text>".
-        const idx = desc.indexOf("Content:");
-        return (idx >= 0 ? desc.slice(idx + "Content:".length) : desc).trim();
-    }
     async fetchMemoryById(id, enc) {
         try {
             const response = await this.axios.get(`/api/extension/memories/${encodeURIComponent(id)}`, {
@@ -630,34 +637,6 @@ class EchoMemApiClient {
             throw error;
         }
     }
-    async searchMemoriesRaw(query, opts, enc, retrievalOnly = false, trace) {
-        const endpoint = "/api/extension/memories/search";
-        let response;
-        try {
-            response = await this.axios.post(endpoint, {
-                query,
-                k: opts.limit,
-                similarityThreshold: opts.threshold,
-                timeFrameDays: opts.timeFrameDays,
-                requestId: opts.requestId,
-                sessionId: this.sessionId,
-            });
-            trace?.({ requestId: opts.requestId, endpoint, httpStatus: response.status });
-        }
-        catch (error) {
-            trace?.({
-                requestId: opts.requestId,
-                endpoint,
-                httpStatus: axios.isAxiosError(error) ? error.response?.status : undefined,
-                errorCode: axios.isAxiosError(error) ? errorCodeFrom(error.response?.data) : undefined,
-            });
-            throw error;
-        }
-        const data = enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
-        return retrievalOnly && isRecord(data)
-            ? { ...data, retrievalOnly: true, tuned: false }
-            : data;
-    }
     async searchMemoriesRetrieved(query, opts, enc, trace) {
         const endpoint = "/api/extension/memories/deep-search/candidates";
         let response;
@@ -732,48 +711,6 @@ class EchoMemApiClient {
             memories,
         };
     }
-    // Tuned recall. Routes through echo-mem-chrome's AUTHENTICATED deep-search proxy
-    // (the same route the Chrome extension uses): it verifies our ec_ token, derives
-    // user_id server-side, and forwards to dg-web's two-phase retriever. The bridge
-    // never hits dg-web directly, so no new auth is needed and no other caller is
-    // disrupted. NOTE: encrypted users still get server-side plaintext only; the
-    // phase-1 + bridge-local-decrypt + phase-2 flow (spec §11) is the remaining work.
-    async searchMemoriesTuned(query, requestId, trace) {
-        const endpoint = "/api/extension/memories/deep-search";
-        let response;
-        try {
-            response = await this.axios.post(endpoint, {
-                query,
-                requestId,
-                logicalRequestId: requestId,
-                sessionId: this.sessionId,
-                userTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
-            });
-            trace?.({ requestId, endpoint, httpStatus: response.status });
-        }
-        catch (error) {
-            trace?.({
-                requestId,
-                endpoint,
-                httpStatus: axios.isAxiosError(error) ? error.response?.status : undefined,
-                errorCode: axios.isAxiosError(error) ? errorCodeFrom(error.response?.data) : undefined,
-            });
-            throw error;
-        }
-        const data = response.data ?? {};
-        if (data.success === false) {
-            trace?.({ requestId, endpoint, httpStatus: response.status, errorCode: errorCodeFrom(data) });
-            throw new Error(`deep-search proxy error: ${data.error || "unknown"}`);
-        }
-        const primary = (data.retrievedMemorySnapshot?.primary ?? []);
-        const memories = primary.map((m) => ({
-            key: String(m.key ?? ""),
-            description: this.cleanMemoryDescription(String(m.description ?? "")),
-            time: m.time,
-            similarity: typeof m.similarity_score === "number" ? m.similarity_score : undefined,
-        }));
-        return { success: true, tuned: true, answer: String(data.answer || data.response || "").trim(), memories };
-    }
     async searchMemories(args, trace) {
         const parsed = searchMemoriesSchema.parse(args ?? {});
         const query = parsed.query?.trim();
@@ -800,18 +737,11 @@ class EchoMemApiClient {
             timeFrameDays: parsed.timeFrameDays,
             requestId: randomUUID(),
         };
-        if (!parsed.includeAnswer) {
-            return this.searchMemoriesRetrieved(query, searchOpts, enc, trace);
-        }
-        // Encrypted account: the server can't synthesize over plaintext it doesn't hold, so use the raw
-        // retriever (returns ciphertext) and decrypt locally — zero-knowledge preserved end-to-end.
-        if (enc.enabled) {
-            return await this.searchMemoriesRaw(query, searchOpts, enc, false, trace);
-        }
-        // A synthesized answer is metered through the legacy route. Do not fall
-        // back to raw retrieval after a ledger outage: that would return a result
-        // without a durable usage fact.
-        return this.searchMemoriesTuned(query, searchOpts.requestId, trace);
+        // MCP recall is retrieval-only. `includeAnswer` remains accepted by the
+        // parser for older clients, but it must never select an EchoMem/dg-web LLM
+        // path. The MCP host model receives the ranked memories and writes the
+        // final answer itself.
+        return this.searchMemoriesRetrieved(query, searchOpts, enc, trace);
     }
     /** Decrypt the model-visible fields on a `{ memories: [...] }` response locally. */
     async decryptResult(data, key) {
@@ -1227,12 +1157,31 @@ class EchoMemMCPServer {
                         ],
                     };
                 }
+                if (error instanceof EncryptionStatusUnavailableError) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: [
+                                    "⚠️ EchoMem could not verify whether this account's vault is encrypted.",
+                                    "No memory data was returned. Retry this action after the service recovers.",
+                                ].join("\n"),
+                            }],
+                        isError: true,
+                    };
+                }
                 if (error instanceof ZodError) {
                     throw new McpError(ErrorCode.InvalidParams, `Invalid arguments: ${error.message}`);
                 }
                 if (error instanceof McpError) {
                     throw error;
                 }
+                const reconnectRequired = formatReconnectRequiredResult(error);
+                if (reconnectRequired) {
+                    return {
+                        content: [{ type: "text", text: reconnectRequired }],
+                        isError: true,
+                    };
+                }
                 const upgradeRequired = formatUpgradeRequiredResult(error);
                 if (upgradeRequired) {
                     return {
@@ -1345,20 +1294,6 @@ class EchoMemMCPServer {
                 .join("\n\n");
             return { content: [{ type: "text", text: `Retrieved ${memories.length} memories:\n\n${formattedResults}` }] };
         }
-        // Tuned two-phase path: synthesized brief + ranked source memories.
-        if (result?.tuned) {
-            const { answer, memories } = result;
-            if (!answer && !memories?.length) {
-                return { content: [{ type: "text", text: "No relevant memories found." }] };
-            }
-            const sources = (memories || [])
-                .map((m, idx) => `[${idx + 1}] ${m.key}${typeof m.similarity === "number" ? ` (sim ${m.similarity.toFixed(3)})` : ""}\n${m.description}`)
-                .join("\n\n");
-            const text = [answer && `Recall:\n${answer}`, sources && `---\nSource memories:\n\n${sources}`]
-                .filter(Boolean)
-                .join("\n\n");
-            return { content: [{ type: "text", text }] };
-        }
         // Fallback: untuned / time-range shape.
         const { success, memories, error } = result;
         if (!success)

package/dist/migrate.js

@@ -525,6 +525,37 @@ export async function cancelQueuedImportSession(client, sessionId) {
         throw new Error("IMPORT_SESSION_ID_REQUIRED");
     await client.patch(`/api/extension/import-sessions/${encodeURIComponent(sessionId)}`, { action: "cancel" });
 }
+async function findRecoverableImportSession(client, sessions, bareConversationId, signal) {
+    const items = sessions.map((session) => ({
+        conversationId: bareConversationId(session),
+        platform: session.source,
+        sourceDate: session.firstTs,
+    }));
+    const response = await client.post("/api/extension/import-sessions/status", { items }, signal ? { signal } : undefined);
+    const data = response.data && typeof response.data === "object"
+        ? response.data
+        : {};
+    const required = new Set(sessions.map((session) => mapKey(session.source, bareConversationId(session))));
+    for (const candidate of data.recoverableSessions ?? []) {
+        const id = typeof candidate.id === "string" ? candidate.id : "";
+        const jobs = Array.isArray(candidate.jobs)
+            ? candidate.jobs
+                .filter((job) => typeof job.id === "string"
+                && typeof job.platform === "string"
+                && typeof job.conversation_id === "string")
+                .map((job) => ({
+                id: job.id,
+                platform: job.platform,
+                conversation_id: job.conversation_id,
+            }))
+            : [];
+        const covered = new Set(jobs.map((job) => mapKey(job.platform, job.conversation_id)));
+        if (id && required.size === jobs.length && [...required].every((key) => covered.has(key))) {
+            return { id, concurrency: MIGRATE_CONCURRENCY, jobs };
+        }
+    }
+    return null;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -984,7 +1015,13 @@ export async function startMigration(opts) {
             throw codedError("FORBIDDEN_SCOPE");
         const data = responseData(e);
         const max = Number(data.maxConversations);
-        if (responseStatus(e) === 422 && data.error === "IMPORT_LIMIT_EXCEEDED" && max > 0) {
+        if (responseStatus(e) === 409 && data.error === "IMPORT_ALREADY_IN_PROGRESS") {
+            const recovered = await findRecoverableImportSession(client, toImport, bareId, opts.signal);
+            if (!recovered)
+                throw e;
+            session = recovered;
+        }
+        else if (responseStatus(e) === 422 && data.error === "IMPORT_LIMIT_EXCEEDED" && max > 0) {
             capped = max;
             toImport = opts.pending.slice(0, max);
             try {

package/dist/setup-page/client-core.js

@@ -23,8 +23,6 @@ export const SETUP_PAGE_CLIENT_CORE = String.raw `      var params = new URLSear
       var progressPollRunId = 0;    // invalidates older progress loops when extraction resumes
       var dashMounted = false;      // dashboard shell (incl. plate iframe) mounted once; persists across /stats polls
       var reportMounted = false;    // report shell (city iframe) mounted once; loading is an overlay on it, not a separate page
-      var authUrl = "";
-      var switchAccountUrl = "";
       var workspacePath = "";
       var billingStatus = null;
       var billingStatusLoading = false;
@@ -34,8 +32,9 @@ export const SETUP_PAGE_CLIENT_CORE = String.raw `      var params = new URLSear
       var sessionPickerQuery = "";
       var sessionPickerSource = "all";
       var billingPollTimer = null;
-      var authWindow = null;
-      var connectionPollStarted = false;
+      var localAuthEmail = "";
+      var localAuthTermsAccepted = false;
+      var localAuthAgeConfirmed = false;
       var statsPollStarted = false;
       var reportPollStarted = false;
       var NIGHT_HOURS = { 22: 1, 23: 1, 0: 1, 1: 1, 2: 1, 3: 1 };
@@ -142,10 +141,6 @@ export const SETUP_PAGE_CLIENT_CORE = String.raw `      var params = new URLSear
         if (code === "NOT_LOGGED_IN") return "Echo on this machine is not signed in yet. Sign in again and retry.";
         return code || "Something went wrong. Retry in a moment.";
       }
-      function closeAuthWindow() {
-        try { if (authWindow && !authWindow.closed) authWindow.close(); } catch (_) {}
-        authWindow = null;
-      }
       function notifyOpenerConnected() {
         try {
           if (window.opener && window.opener !== window && !window.opener.closed) {
@@ -156,24 +151,197 @@ export const SETUP_PAGE_CLIENT_CORE = String.raw `      var params = new URLSear
         } catch (_) {}
         return false;
       }
-      function openAuthWindow(url) {
-        var targetUrl = url || authUrl;
-        if (!targetUrl) return false;
+      function localAuthLegalHtml() {
+        return '<div class="localAuthLegal">' +
+          '<label><input type="checkbox" id="localAuthAge" ' + (localAuthAgeConfirmed ? "checked" : "") + ' />' +
+            '<span>I confirm that I am at least 18 years old.</span></label>' +
+          '<label><input type="checkbox" id="localAuthTerms" ' + (localAuthTermsAccepted ? "checked" : "") + ' />' +
+            '<span>I have read and agree to the Echo <a href="https://echoknows.com/terms-of-use" target="_blank" rel="noopener noreferrer">Terms of Use</a>, <a href="https://echoknows.com/memory-terms" target="_blank" rel="noopener noreferrer">Memory Usage Terms</a>, and <a href="https://echoknows.com/privacy-policy" target="_blank" rel="noopener noreferrer">Privacy Policy</a>. I understand Echo uses subprocessors listed <a href="https://echoknows.com/subprocessor-list" target="_blank" rel="noopener noreferrer">here</a>.</span></label>' +
+        '</div>';
+      }
+      function captureLocalAuthConsents() {
+        var terms = document.getElementById("localAuthTerms");
+        var age = document.getElementById("localAuthAge");
+        localAuthTermsAccepted = !!(terms && terms.checked);
+        localAuthAgeConfirmed = !!(age && age.checked);
+      }
+      function setLocalAuthStatus(message, tone) {
+        var node = document.getElementById("localAuthStatus");
+        if (!node) return;
+        node.textContent = message || "";
+        node.classList.toggle("is-error", tone === "error");
+      }
+      function updateLocalAuthSendButton() {
+        captureLocalAuthConsents();
+        var email = document.getElementById("localAuthEmail");
+        var button = document.getElementById("localAuthSend");
+        if (!button) return;
+        var value = email && email.value ? String(email.value).trim() : "";
+        button.disabled = !value || !localAuthTermsAccepted || !localAuthAgeConfirmed;
+      }
+      function renderLocalLogin(message) {
+        setCityMode(false);
+        setScanMode(false);
+        setExtractMode(false);
+        setReadyMode(true);
+        setHead("Connect EchoMem", "Local login");
+        app.className = "localAuthStage";
+        app.innerHTML =
+          '<section class="localAuthCard">' +
+            '<div class="localAuthLead">' +
+              '<img src="/hud-assets/echo-face-cutout.png" alt="" />' +
+              '<p class="consentEyebrow">EchoMem account / local login</p>' +
+              '<h2 class="siteHeadline">Sign in without leaving this device.</h2>' +
+              '<p>Echo sends a one-time code to your email. The browser stays on localhost; your device token and encryption key are stored only in the local EchoMem keystore.</p>' +
+            '</div>' +
+            '<form class="localAuthForm" id="localAuthEmailForm">' +
+              '<label class="localAuthField"><span>Email</span><input id="localAuthEmail" type="email" autocomplete="email" placeholder="you@example.com" value="' + esc(localAuthEmail) + '" /></label>' +
+              localAuthLegalHtml() +
+              '<button class="primary" id="localAuthSend" type="submit">Send code</button>' +
+              '<p class="localAuthStatus' + (message ? " is-error" : "") + '" id="localAuthStatus" role="status" aria-live="polite">' + esc(message || "") + '</p>' +
+            '</form>' +
+          '</section>';
+        var form = document.getElementById("localAuthEmailForm");
+        if (form) form.onsubmit = function (event) { event.preventDefault(); void sendLocalOtp(); };
+        var email = document.getElementById("localAuthEmail");
+        if (email) {
+          email.oninput = function () { localAuthEmail = String(email.value || ""); updateLocalAuthSendButton(); };
+          email.focus();
+        }
+        var terms = document.getElementById("localAuthTerms");
+        var age = document.getElementById("localAuthAge");
+        if (terms) terms.onchange = updateLocalAuthSendButton;
+        if (age) age.onchange = updateLocalAuthSendButton;
+        updateLocalAuthSendButton();
+      }
+      async function sendLocalOtp() {
+        var email = document.getElementById("localAuthEmail");
+        localAuthEmail = email && email.value ? String(email.value).trim().toLowerCase() : "";
+        captureLocalAuthConsents();
+        if (!localAuthEmail) { setLocalAuthStatus("Enter your email.", "error"); return; }
+        if (!localAuthAgeConfirmed || !localAuthTermsAccepted) {
+          setLocalAuthStatus("Confirm your age and accept Echo's terms before continuing.", "error");
+          return;
+        }
+        var button = document.getElementById("localAuthSend");
+        if (button) { button.disabled = true; button.textContent = "Sending..."; }
+        setLocalAuthStatus("Sending verification code...");
         try {
-          authWindow = window.open(targetUrl, "echomem-signin-" + nonce, "popup=yes,width=560,height=760");
-          if (!authWindow) return false;
-          authWindow.focus();
-          return true;
-        } catch (_) { return false; }
-      }
-      function showPopupFallback(message, url) {
-        Array.prototype.forEach.call(document.querySelectorAll("[data-signin-help]"), function (hint) {
-          hint.textContent = message || "Your browser blocked the secure sign-in window. Use the button below, then this page will resume when sign-in returns.";
-        });
-        Array.prototype.forEach.call(document.querySelectorAll("[data-signin-fallback]"), function (fallback) {
-          fallback.setAttribute("href", url || authUrl);
-          fallback.classList.remove("hidden");
-        });
+          var data = await postJson("/local-auth/send-otp", {
+            email: localAuthEmail,
+            acceptedTerms: localAuthTermsAccepted,
+            ageConfirmed: localAuthAgeConfirmed
+          }, 12000);
+          localAuthEmail = data.email || localAuthEmail;
+          renderLocalOtp("Code sent. Check your inbox.");
+        } catch (error) {
+          if (button) { button.disabled = false; button.textContent = "Send code"; }
+          setLocalAuthStatus(error && error.message ? error.message : "Could not send the code.", "error");
+        }
+      }
+      function renderLocalOtp(message) {
+        setCityMode(false);
+        setScanMode(false);
+        setExtractMode(false);
+        setReadyMode(true);
+        setHead("Check your email", "Local login");
+        app.className = "localAuthStage";
+        app.innerHTML =
+          '<section class="localAuthCard localAuthCardOtp">' +
+            '<div class="localAuthLead">' +
+              '<img src="/hud-assets/echo-face-cutout.png" alt="" />' +
+              '<p class="consentEyebrow">Verification code</p>' +
+              '<h2 class="siteHeadline">Enter the code sent to <strong>' + esc(localAuthEmail) + '</strong>.</h2>' +
+              '<p>This code signs in this local EchoMem bridge only. The next step asks for your encryption passphrase.</p>' +
+            '</div>' +
+            '<form class="localAuthForm" id="localAuthOtpForm">' +
+              '<label class="localAuthField"><span>6-digit code</span><input id="localAuthOtp" type="text" inputmode="numeric" autocomplete="one-time-code" maxlength="6" placeholder="123456" /></label>' +
+              '<div class="localAuthActions"><button class="primary" id="localAuthVerify" type="submit">Verify code</button><button class="textButton" id="localAuthBack" type="button">Use a different email</button></div>' +
+              '<p class="localAuthStatus" id="localAuthStatus" role="status" aria-live="polite">' + esc(message || "") + '</p>' +
+            '</form>' +
+          '</section>';
+        var form = document.getElementById("localAuthOtpForm");
+        if (form) form.onsubmit = function (event) { event.preventDefault(); void verifyLocalOtp(); };
+        var back = document.getElementById("localAuthBack");
+        if (back) back.onclick = function () { renderLocalLogin(""); };
+        var otp = document.getElementById("localAuthOtp");
+        if (otp) otp.focus();
+      }
+      async function verifyLocalOtp() {
+        var otpInput = document.getElementById("localAuthOtp");
+        var otp = otpInput && otpInput.value ? String(otpInput.value).replace(/\\D/g, "") : "";
+        if (otp.length !== 6) { setLocalAuthStatus("Enter the 6-digit code.", "error"); return; }
+        var button = document.getElementById("localAuthVerify");
+        if (button) { button.disabled = true; button.textContent = "Verifying..."; }
+        setLocalAuthStatus("Verifying code...");
+        try {
+          var data = await postJson("/local-auth/verify-otp", {
+            email: localAuthEmail,
+            otp: otp,
+            acceptedTerms: localAuthTermsAccepted,
+            ageConfirmed: localAuthAgeConfirmed
+          }, 18000);
+          if (data && data.stage === "passphrase") {
+            renderLocalPassphrase(data.mode || "unlock", data.email || localAuthEmail);
+            return;
+          }
+          connected = true;
+          await waitForStats();
+        } catch (error) {
+          if (button) { button.disabled = false; button.textContent = "Verify code"; }
+          setLocalAuthStatus(error && error.message ? error.message : "Could not verify the code.", "error");
+        }
+      }
+      function renderLocalPassphrase(mode, email, message) {
+        localAuthEmail = email || localAuthEmail;
+        var setupMode = mode === "setup";
+        setCityMode(false);
+        setScanMode(false);
+        setExtractMode(false);
+        setReadyMode(true);
+        setHead(setupMode ? "Create encrypted vault" : "Unlock encrypted vault", "Local passphrase");
+        app.className = "localAuthStage";
+        app.innerHTML =
+          '<section class="localAuthCard localAuthCardPassphrase">' +
+            '<div class="localAuthLead">' +
+              '<img src="/hud-assets/echo-face-cutout.png" alt="" />' +
+              '<p class="consentEyebrow">Encryption passphrase</p>' +
+              '<h2 class="siteHeadline">' + (setupMode ? 'Create your local vault passphrase.' : 'Enter your vault passphrase.') + '</h2>' +
+              '<p>' + (setupMode ? 'Echo derives your encryption key on this device. The passphrase and key are never sent to EchoMem. If you forget it, encrypted memories cannot be recovered.' : 'Echo verifies this passphrase locally against your account encryption token. The passphrase is never sent to EchoMem.') + '</p>' +
+            '</div>' +
+            '<form class="localAuthForm" id="localAuthPassphraseForm">' +
+              '<label class="localAuthField"><span>Passphrase</span><input id="localAuthPassphrase" type="password" autocomplete="' + (setupMode ? "new-password" : "current-password") + '" placeholder="Encryption passphrase" /></label>' +
+              (setupMode ? '<label class="localAuthField"><span>Confirm passphrase</span><input id="localAuthPassphraseConfirm" type="password" autocomplete="new-password" placeholder="Confirm passphrase" /></label>' : '') +
+              '<div class="localAuthActions"><button class="primary" id="localAuthUnlock" type="submit">' + (setupMode ? "Create vault" : "Unlock") + '</button><button class="textButton" id="localAuthRestart" type="button">Use a different email</button></div>' +
+              '<p class="localAuthStatus' + (message ? " is-error" : "") + '" id="localAuthStatus" role="status" aria-live="polite">' + esc(message || "") + '</p>' +
+            '</form>' +
+          '</section>';
+        var form = document.getElementById("localAuthPassphraseForm");
+        if (form) form.onsubmit = function (event) { event.preventDefault(); void submitLocalPassphrase(setupMode); };
+        var restart = document.getElementById("localAuthRestart");
+        if (restart) restart.onclick = function () { renderLocalLogin(""); };
+        var pass = document.getElementById("localAuthPassphrase");
+        if (pass) pass.focus();
+      }
+      async function submitLocalPassphrase(setupMode) {
+        var pass = document.getElementById("localAuthPassphrase");
+        var confirm = document.getElementById("localAuthPassphraseConfirm");
+        var passphrase = pass && typeof pass.value === "string" ? pass.value : "";
+        var confirmValue = confirm && typeof confirm.value === "string" ? confirm.value : "";
+        if (passphrase.length < 4) { setLocalAuthStatus("Use at least 4 characters.", "error"); return; }
+        if (setupMode && passphrase !== confirmValue) { setLocalAuthStatus("Passphrases do not match.", "error"); return; }
+        var button = document.getElementById("localAuthUnlock");
+        if (button) { button.disabled = true; button.textContent = setupMode ? "Creating..." : "Unlocking..."; }
+        setLocalAuthStatus(setupMode ? "Creating encrypted vault..." : "Unlocking vault...");
+        try {
+          await postJson("/local-auth/passphrase", { passphrase: passphrase }, 30000);
+          connected = true;
+          await waitForStats();
+        } catch (error) {
+          if (button) { button.disabled = false; button.textContent = setupMode ? "Create vault" : "Unlock"; }
+          var msg = error && error.message ? error.message : "Could not unlock encrypted memory.";
+          renderLocalPassphrase(setupMode ? "setup" : "unlock", localAuthEmail, msg);
+        }
       }
       function onConnectClick() {
         if (!localHistoryConsentGranted) {
@@ -182,8 +350,7 @@ export const SETUP_PAGE_CLIENT_CORE = String.raw `      var params = new URLSear
           return;
         }
         if (connected) { void waitForStats(); return; }
-        if (!openAuthWindow(authUrl)) showPopupFallback("", authUrl);
-        startConnectionPoll();
+        renderLocalLogin("");
       }
       function bindConnect() {
         Array.prototype.forEach.call(document.querySelectorAll("[data-connect-echo]"), function (signin) {