mcp-scraper 0.33.4 → 0.33.6

package/dist/{server-LNCSY6ME.js → server-SHOYO52X.js}

@@ -6,7 +6,7 @@ import {
   createHarvestAttemptRecorder,
   harvestProblemResponse,
   serializeHarvestProblem
-} from "./chunk-SDHPQTFM.js";
+} from "./chunk-C2OD4ELT.js";
 import {
   BrowserDriver,
   MapsSelectors,
@@ -15,7 +15,7 @@ import {
   harvest,
   resolveKernelProxyId,
   serpArrivalUrl
-} from "./chunk-ERORC7AP.js";
+} from "./chunk-A54ELKJK.js";
 import {
   HttpMcpToolExecutor,
   assessTranscriptSignal,
@@ -35,7 +35,7 @@ import {
   sanitizeAttempts,
   sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-ACBNIIBU.js";
+} from "./chunk-6ZUK4H66.js";
 import {
   auditImages,
   buildLinkReport,
@@ -52,7 +52,7 @@ import {
   recordKernelSession,
   recordVendorUsage,
   runWithCostContext
-} from "./chunk-MTSBI7ZH.js";
+} from "./chunk-WJJTGRK4.js";
 import {
   csvRecords,
   listWorkflowDefinitions,
@@ -76,7 +76,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-V73MPRU6.js";
-import "./chunk-IQ742H22.js";
+import "./chunk-F65IIUHI.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -87,11 +87,12 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-3ZZOLQ6A.js";
+} from "./chunk-XL6YIWJ3.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
-  CONNECTED_ACTIVE_CONNECTION_MONTHLY_USD,
+  CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
+  CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC,
   CONNECTED_COMPUTE_CREDITS_PER_SECOND,
   CONNECTED_FUNCTION_RUN_CREDITS,
   CONNECTED_FUNCTION_RUN_MC,
@@ -123,9 +124,10 @@ import {
   concurrencySlotBillingInfo,
   getPublicRatesPayload,
   insufficientBalanceResponse,
+  mcToCredits,
   serpActualCostMc,
   vendorCostUsdToMc
-} from "./chunk-4767BA2O.js";
+} from "./chunk-LKIP7VDN.js";
 import {
   CaptchaError,
   ExtractionError,
@@ -211,7 +213,7 @@ import {
   settleDebitMcIdempotent,
   upsertPageSnapshot,
   verifyPassword
-} from "./chunk-ICT7DDHL.js";
+} from "./chunk-AIK7WQD5.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -7369,7 +7371,7 @@ var siteExtractFn = inngest.createFunction(
       return buildSeoAudit(pages, job.startUrl);
     }) : null;
     const artifacts = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-NFFVMUMT.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-YNXTFCC3.js");
       const stored = await assembleExtractArtifacts(job, { branding, imageAudit, seoAudit });
       await completeExtractJob(jobId, stored);
       return stored;
@@ -13079,15 +13081,115 @@ videoApp.post("/status", createApiKeyAuth(), async (c) => {
 // src/api/maps-routes.ts
 import { Hono as Hono11 } from "hono";
 
+// src/extractor/GoogleBusinessPanel.ts
+function clickNamedBusinessCardInBrowser(businessName) {
+  const normalize = (value) => (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+  const expected = normalize(businessName);
+  const headings = Array.from(document.querySelectorAll('div[role="heading"], h3')).filter((heading) => normalize(heading.textContent) === expected);
+  for (const heading of headings) {
+    if (heading.closest('[role="dialog"], dialog')) continue;
+    const directlyClickable = heading.closest(
+      'button, a, [role="button"], [role="link"], [jsaction]'
+    );
+    if (directlyClickable) {
+      directlyClickable.click();
+      return true;
+    }
+    let target = heading;
+    for (let hop = 0; hop < 8; hop++) {
+      const parent = target.parentElement;
+      if (!parent || parent.querySelectorAll('div[role="heading"], h3').length > 1) break;
+      target = parent;
+    }
+    target.click();
+    return true;
+  }
+  return false;
+}
+function clickBusinessPanelRowInBrowser(input) {
+  const normalize = (value) => (value ?? "").replace(/\s+/g, " ").trim();
+  const expectedBusiness = normalize(input.businessName).toLowerCase();
+  const visible = (element) => element.getAttribute("aria-hidden") !== "true" && (element.offsetParent !== null || element.getClientRects().length > 0);
+  const dialogs = Array.from(document.querySelectorAll('dialog, [role="dialog"]')).filter((dialog) => visible(dialog) && normalize(dialog.innerText).toLowerCase().includes(expectedBusiness)).reverse();
+  for (const dialog of dialogs) {
+    const row = Array.from(
+      dialog.querySelectorAll('button, a, [role="button"]')
+    ).find((element) => visible(element) && normalize(element.innerText).startsWith(input.prefix));
+    if (row) {
+      row.click();
+      return true;
+    }
+  }
+  return false;
+}
+function extractOpenBusinessPanelDialogItemsInBrowser(expectedHeading) {
+  const normalize = (value) => (value ?? "").trim();
+  const dialogs = Array.from(document.querySelectorAll('dialog, [role="dialog"]')).filter((dialog) => dialog.getAttribute("aria-hidden") !== "true").reverse();
+  const matchingDialog = dialogs.find((dialog) => {
+    const heading2 = dialog.querySelector('h1, h2, [role="heading"]');
+    return normalize(heading2?.innerText || heading2?.textContent).startsWith(expectedHeading);
+  });
+  if (!matchingDialog) return [];
+  const heading = matchingDialog.querySelector('h1, h2, [role="heading"]');
+  const headingLines = new Set(
+    normalize(heading?.innerText || heading?.textContent).split("\n").map((value) => value.trim()).filter(Boolean)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  matchingDialog.querySelectorAll("*").forEach((element) => {
+    if (heading?.contains(element)) return;
+    if (element.children.length > 0) return;
+    const value = normalize(element.innerText || element.textContent);
+    if (!value || headingLines.has(value) || seen.has(value)) return;
+    if (/^(back|close|done|thanks)$/i.test(value)) return;
+    if (/^serves\s.*following/i.test(value)) return;
+    seen.add(value);
+    items.push(value);
+  });
+  return items;
+}
+function closeOpenBusinessPanelDialogInBrowser(expectedHeading) {
+  const dialogs = Array.from(document.querySelectorAll('dialog, [role="dialog"]')).filter((dialog) => dialog.getAttribute("aria-hidden") !== "true").reverse();
+  const matchingDialog = dialogs.find((dialog) => {
+    const heading = dialog.querySelector('h1, h2, [role="heading"]');
+    return (heading?.innerText || heading?.textContent || "").trim().startsWith(expectedHeading);
+  });
+  const close = matchingDialog?.querySelector(
+    '[aria-label*="Close" i], button[aria-label*="close" i]'
+  );
+  close?.click();
+  return Boolean(close);
+}
+async function clickPanelRowWithRetry(page, businessName, prefix) {
+  const input = { businessName, prefix };
+  if (await page.evaluate(clickBusinessPanelRowInBrowser, input)) return true;
+  await page.waitForTimeout(1500);
+  return page.evaluate(clickBusinessPanelRowInBrowser, input);
+}
+async function extractExpandedList(page, businessName, rowPrefix, dialogHeading) {
+  if (!await clickPanelRowWithRetry(page, businessName, rowPrefix)) return [];
+  await page.waitForTimeout(500);
+  const items = await page.evaluate(
+    extractOpenBusinessPanelDialogItemsInBrowser,
+    dialogHeading
+  );
+  await page.evaluate(closeOpenBusinessPanelDialogInBrowser, dialogHeading);
+  await page.waitForTimeout(250);
+  return items;
+}
+async function extractExpandedGoogleBusinessPanelServices(page, businessName) {
+  const services = await extractExpandedList(page, businessName, "Services:", "Services");
+  const areasServed = await extractExpandedList(page, businessName, "Serves ", "Areas Served");
+  return { services, areasServed };
+}
+function completeCollapsedPanelValues(values) {
+  return values.filter((value) => !/(?:\.{3}|…)\s*$/.test(value.trim()));
+}
+
 // src/extractor/MapsSearchExtractor.ts
 var LOCAL_RESULTS_PAGE_LIMIT = 8;
 var LOCAL_RESULTS_WAIT_MS = 1e3;
 var MAPS_REDIRECT_BASE = "https://serp-redirector.vercel.app";
-function buildGoogleLocalResultsUrl(input) {
-  const query = [input.query, input.location].filter(Boolean).join(" ");
-  const params = new URLSearchParams({ q: query, udm: "1", gl: input.gl, hl: input.hl, pws: "0" });
-  return `https://www.google.com/search?${params.toString()}`;
-}
 function buildGoogleOrganicSearchUrl(input) {
   const query = [input.query, input.location].filter(Boolean).join(" ");
   const params = new URLSearchParams({ q: query, gl: input.gl, hl: input.hl, pws: "0" });
@@ -13354,6 +13456,11 @@ var MapsSearchExtractor = class {
         areasServed
       };
     }, includeServices);
+    if (includeServices) {
+      const expanded = await extractExpandedGoogleBusinessPanelServices(page, card.name);
+      details.services = expanded.services.length > 0 ? expanded.services : completeCollapsedPanelValues(details.services);
+      details.areasServed = expanded.areasServed.length > 0 ? expanded.areasServed : completeCollapsedPanelValues(details.areasServed);
+    }
     await this.closeDialog(page);
     return details;
   }
@@ -13398,6 +13505,7 @@ var MapsSearchExtractor = class {
 };
 
 // src/extractor/MapsNavigator.ts
+var BUSINESS_PANEL_REDIRECT_BASE = "https://serp-redirector.vercel.app";
 var MapsNavigator = class {
   constructor(page) {
     this.page = page;
@@ -13455,26 +13563,67 @@ var MapsNavigator = class {
     await this.page.waitForSelector('[role="main"] h2', { timeout: 5e3 }).catch(() => {
     });
   }
-  async navigateToSerpBusinessPanel(businessName, location2, gl, hl) {
-    const searchUrl = buildGoogleLocalResultsUrl({ query: businessName, location: location2, gl, hl });
-    await this.page.goto(searchUrl, { waitUntil: "domcontentloaded", timeout: 45e3 }).catch(() => {
+  async navigateToSerpBusinessPanel(businessName, location2, gl, hl, category) {
+    const searchUrl = buildGoogleOrganicSearchUrl({
+      query: category?.trim() || businessName,
+      location: location2,
+      gl,
+      hl
     });
-    await this.page.waitForTimeout(1e3);
-    const clicked = await this.page.evaluate((name) => {
-      const normalized = name.replace(/\s+/g, " ").trim().toLowerCase();
-      const card = Array.from(document.querySelectorAll("button")).find(
-        (button) => button.querySelector("h3")?.textContent?.replace(/\s+/g, " ").trim().toLowerCase() === normalized
-      );
-      if (card) {
-        card.click();
-        return true;
-      }
-      return false;
-    }, businessName);
-    if (!clicked) return false;
-    await this.page.waitForSelector('dialog, [role="dialog"]', { timeout: 5e3 }).catch(() => {
+    const arrivalUrl = serpArrivalUrl(
+      searchUrl,
+      process.env.SERP_REDIRECT_BASE?.trim() || BUSINESS_PANEL_REDIRECT_BASE
+    );
+    await this.page.goto(arrivalUrl, { waitUntil: "domcontentloaded", timeout: 45e3 }).catch(() => {
+    });
+    await this.page.waitForTimeout(2e3);
+    if (await this.isGoogleChallenge()) return false;
+    await this.waitForNamedBusinessCard(businessName, 5e3);
+    if (await this.page.evaluate(clickNamedBusinessCardInBrowser, businessName)) {
+      return this.waitForBusinessDialog(businessName);
+    }
+    const moreBusinesses = this.page.getByRole("link", { name: /more (businesses|places|results)/i }).or(this.page.getByRole("button", { name: /more (businesses|places|results)/i })).first();
+    if (!await moreBusinesses.isVisible({ timeout: 5e3 }).catch(() => false)) return false;
+    await moreBusinesses.click({ timeout: 1e4 }).catch(() => {
+    });
+    await this.page.waitForTimeout(3e3);
+    if (await this.isGoogleChallenge()) return false;
+    await this.waitForNamedBusinessCard(businessName, 3e3);
+    if (!await this.page.evaluate(clickNamedBusinessCardInBrowser, businessName)) {
+      const searchBox = this.page.locator('textarea[name="q"]:visible, input[name="q"]:visible').first();
+      if (!await searchBox.isVisible({ timeout: 5e3 }).catch(() => false)) return false;
+      await searchBox.fill(`${businessName} ${location2}`);
+      await searchBox.press("Enter");
+      await this.page.waitForTimeout(3e3);
+      if (await this.isGoogleChallenge()) return false;
+      await this.waitForNamedBusinessCard(businessName, 1e4);
+      if (!await this.page.evaluate(clickNamedBusinessCardInBrowser, businessName)) return false;
+    }
+    return this.waitForBusinessDialog(businessName);
+  }
+  async isGoogleChallenge() {
+    return this.page.evaluate(() => {
+      const text2 = (document.body?.innerText ?? "").slice(0, 2e3);
+      return /unusual traffic|captcha|recaptcha|about this page/i.test(text2) || /\/sorry\//.test(location.href);
+    }).catch(() => true);
+  }
+  async waitForNamedBusinessCard(businessName, timeout) {
+    if (typeof this.page.waitForFunction !== "function") return;
+    await this.page.waitForFunction(
+      (expectedName) => {
+        const normalize = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+        const expected = normalize(expectedName);
+        return Array.from(document.querySelectorAll('div[role="heading"], h3')).some((element) => normalize(element.textContent ?? "") === expected);
+      },
+      businessName,
+      { timeout }
+    ).catch(() => void 0);
+  }
+  async waitForBusinessDialog(businessName) {
+    const dialog = this.page.locator('dialog:visible, [role="dialog"]:visible').filter({ hasText: businessName }).first();
+    await dialog.waitFor({ state: "visible", timeout: 1e4 }).catch(() => {
     });
-    return this.page.locator('dialog, [role="dialog"]').count().then((count) => count > 0);
+    return dialog.isVisible().catch(() => false);
   }
   buildReviewsUrl(placeUrl) {
     const fid = placeUrl.match(/!1s(0x[0-9a-f]+:0x[0-9a-f]+)/i);
@@ -13519,6 +13668,71 @@ var MapsNavigator = class {
   }
 };
 
+// src/extractor/GoogleBusinessPanelRotation.ts
+async function extractGoogleBusinessPanelServicesWithRotation(options) {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 5);
+  for (let attemptIndex = 0; attemptIndex < maxAttempts; attemptIndex += 1) {
+    const driver = new BrowserDriver();
+    const attemptNumber = attemptIndex + 1;
+    const useDefaultProxy = attemptIndex < 2;
+    const useHeadful = attemptIndex === maxAttempts - 1;
+    try {
+      await driver.launch({
+        headless: useHeadful ? false : options.headless,
+        headlessMode: useHeadful ? "headful" : options.headless ? "headless" : "headful",
+        kernelApiKey: options.kernelApiKey,
+        keepDefaultProxy: useDefaultProxy,
+        proxyMode: "none",
+        viewport: { width: 1280, height: 900 },
+        locale: `${options.hl}-${options.gl.toUpperCase()}`
+      });
+      const page = driver.getPage();
+      const opened = await new MapsNavigator(page).navigateToSerpBusinessPanel(
+        options.businessName,
+        options.location,
+        options.gl,
+        options.hl,
+        options.category
+      );
+      if (!opened) {
+        console.warn(JSON.stringify({
+          event: "maps_place_services_panel_not_opened",
+          attempt_number: attemptNumber,
+          max_attempts: maxAttempts,
+          keep_default_proxy: useDefaultProxy,
+          headless_mode: useHeadful ? "headful" : options.headless ? "headless" : "headful",
+          final_url: page.url()
+        }));
+        continue;
+      }
+      const result = await extractExpandedGoogleBusinessPanelServices(
+        page,
+        options.businessName
+      );
+      return {
+        ...result,
+        opened: true,
+        attempts: attemptNumber
+      };
+    } catch (error) {
+      console.warn(JSON.stringify({
+        event: "maps_place_services_attempt_failed",
+        attempt_number: attemptNumber,
+        max_attempts: maxAttempts,
+        message: error instanceof Error ? error.message : String(error)
+      }));
+    } finally {
+      await driver.close().catch(() => void 0);
+    }
+  }
+  return {
+    services: [],
+    areasServed: [],
+    opened: false,
+    attempts: maxAttempts
+  };
+}
+
 // src/extractor/MapsReviewCollector.ts
 var REVIEW_SCROLL_BUDGET_MS = 45e3;
 var REVIEW_SCROLL_STEP_MS = 1200;
@@ -13650,14 +13864,33 @@ var MapsExtractor = class {
       let servicesStatus = "not_requested";
       if (options.includeServices) {
         try {
-          const opened = await navigator.navigateToSerpBusinessPanel(options.businessName, options.location, options.gl, options.hl);
+          let opened = await navigator.navigateToSerpBusinessPanel(
+            options.businessName,
+            options.location,
+            options.gl,
+            options.hl,
+            overview.category ?? void 0
+          );
           if (opened) {
-            const result = await this.extractServicesAndAreasServed(page);
+            const result = await extractExpandedGoogleBusinessPanelServices(page, options.businessName);
             services = result.services;
             areasServed = result.areasServed;
             servicesStatus = services.length > 0 || areasServed.length > 0 ? "collected" : "none_exist";
           } else {
-            servicesStatus = "unavailable";
+            await this.driver.close().catch(() => void 0);
+            const result = await extractGoogleBusinessPanelServicesWithRotation({
+              businessName: options.businessName,
+              location: options.location,
+              category: overview.category ?? void 0,
+              gl: options.gl,
+              hl: options.hl,
+              headless: options.headless,
+              kernelApiKey: options.kernelApiKey
+            });
+            opened = result.opened;
+            services = result.services;
+            areasServed = result.areasServed;
+            servicesStatus = opened ? services.length > 0 || areasServed.length > 0 ? "collected" : "none_exist" : "unavailable";
           }
         } catch (err) {
           console.warn("[MapsExtractor] services/areas-served extraction failed:", err instanceof Error ? err.message : String(err));
@@ -13870,18 +14103,6 @@ var MapsExtractor = class {
     }
     return result.data;
   }
-  async extractServicesAndAreasServed(page) {
-    return page.evaluate(() => {
-      const visible = Array.from(document.querySelectorAll('dialog, [role="dialog"]')).find((dialog) => dialog.offsetParent !== null);
-      if (!visible) return { services: [], areasServed: [] };
-      const values = Array.from(visible.querySelectorAll("button")).map((button) => button.innerText.replace(/\s+/g, " ").trim()).filter(Boolean);
-      const servicesText = values.find((value) => /^services\s*:/i.test(value));
-      const services = servicesText ? [...new Set(servicesText.replace(/^services\s*:\s*/i, "").split(/\s*[,·]\s*/).map((value) => value.trim()).filter(Boolean))] : [];
-      const served = values.find((value) => /^serves\b/i.test(value));
-      const areasServed = served ? [served.replace(/^serves\s*/i, "").trim()].filter(Boolean) : [];
-      return { services, areasServed };
-    });
-  }
 };
 
 // src/maps-search-rotation.ts
@@ -19574,13 +19795,11 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 }
 
 // src/api/stripe-routes.ts
-import Stripe2 from "stripe";
+import Stripe from "stripe";
 import { Hono as Hono19 } from "hono";
 
 // src/api/connected-account-billing.ts
-import Stripe from "stripe";
 var DEFAULT_CONNECTED_ACCOUNT_PRICE_ID = "price_1TtYPAS8aAcsk3TGHOgrDZiQ";
-var STRIPE_API_VERSION = "2026-02-25.clover";
 async function ensureConnectedAccountBillingSchema() {
   await getDb().execute(`CREATE TABLE IF NOT EXISTS connected_account_billing (
     user_id INTEGER PRIMARY KEY,
@@ -19634,14 +19853,16 @@ async function setConnectedAccountBillingState(input) {
   return state;
 }
 var ConnectedAccountBillingError = class extends Error {
-  constructor(message, code, status = 409) {
+  constructor(message, code, status = 409, details) {
     super(message);
     this.code = code;
     this.status = status;
+    this.details = details;
     this.name = "ConnectedAccountBillingError";
   }
   code;
   status;
+  details;
 };
 function connectedAccountPriceId() {
   const configured = process.env.CONNECTED_ACCOUNT_PRICE_ID?.trim();
@@ -19652,12 +19873,12 @@ function connectedAccountBillingView(actualQuantity, state) {
   const quantity = Math.max(0, Math.round(actualQuantity));
   return {
     provider: "nango",
-    billingMode: "flat_recurring_usd_plus_credits",
+    billingMode: "flat_recurring_credits",
     priceId: connectedAccountPriceId(),
-    unitAmountUsd: CONNECTED_ACTIVE_CONNECTION_MONTHLY_USD,
+    unitAmountCredits: CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
     interval: "month",
     quantity,
-    projectedMonthlyUsd: quantity * CONNECTED_ACTIVE_CONNECTION_MONTHLY_USD,
+    projectedMonthlyCredits: quantity * CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
     status: state?.status ?? "pending",
     lastErrorCode: state?.last_error_code ?? null,
     syncedAt: state?.synced_at ?? null,
@@ -19667,29 +19888,23 @@ function connectedAccountBillingView(actualQuantity, state) {
 function findBasePlanItem(subscription) {
   return subscription.items.data.find((item) => !!item.price?.id && item.price.id in SUBSCRIPTION_TIERS);
 }
-function findConnectedAccountItem(subscription, priceId = connectedAccountPriceId()) {
-  return priceId ? subscription.items.data.find((item) => item.price?.id === priceId) : void 0;
-}
-function liveSubscription(subscription) {
-  return subscription.status === "active" || subscription.status === "trialing";
-}
-function safeStripeErrorCode(error) {
+function safeErrorCode(error) {
   if (error instanceof ConnectedAccountBillingError) return error.code;
   return "stripe_connection_billing_failed";
 }
-async function persistFailure(user, actualQuantity, error, subscriptionItemId = null) {
+async function persistFailure(user, quantityToPersist, error) {
   await setConnectedAccountBillingState({
     userId: user.id,
     stripeSubscriptionId: user.subscription_id,
-    stripeSubscriptionItemId: subscriptionItemId,
+    stripeSubscriptionItemId: null,
     priceId: connectedAccountPriceId(),
-    quantity: actualQuantity,
+    quantity: quantityToPersist,
     status: error instanceof ConnectedAccountBillingError && error.code !== "stripe_connection_billing_failed" ? "blocked" : "error",
-    lastErrorCode: safeStripeErrorCode(error),
+    lastErrorCode: safeErrorCode(error),
     synced: false
   });
 }
-async function reconcileConnectedAccountBilling(user, actualQuantity, stripeClient) {
+async function reconcileConnectedAccountBilling(user, actualQuantity) {
   if (!Number.isSafeInteger(actualQuantity) || actualQuantity < 0) {
     throw new Error("actualQuantity must be a non-negative safe integer");
   }
@@ -19703,7 +19918,7 @@ async function reconcileConnectedAccountBilling(user, actualQuantity, stripeClie
     await persistFailure(user, actualQuantity, error);
     throw error;
   }
-  if (!user.subscription_id) {
+  if (!user.subscription_id || !(user.subscription_tier ?? "") || !Object.values(SUBSCRIPTION_TIERS).some((t) => t.tier === user.subscription_tier)) {
     if (actualQuantity === 0) {
       const state = await setConnectedAccountBillingState({
         userId: user.id,
@@ -19725,48 +19940,38 @@ async function reconcileConnectedAccountBilling(user, actualQuantity, stripeClie
     await persistFailure(user, actualQuantity, error);
     throw error;
   }
-  const client2 = stripeClient ?? (() => {
-    const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
-    if (!secret2) {
-      throw new ConnectedAccountBillingError(
-        "Stripe is not configured.",
-        "connected_account_price_not_configured",
-        503
-      );
-    }
-    return new Stripe(secret2, { apiVersion: STRIPE_API_VERSION });
-  })();
-  let currentItem;
+  const existingState = await getConnectedAccountBillingState(user.id);
+  const currentQuantity = Math.max(0, existingState?.quantity ?? 0);
   try {
-    const subscription = await client2.subscriptions.retrieve(user.subscription_id);
-    currentItem = findConnectedAccountItem(subscription, priceId);
-    if (!liveSubscription(subscription)) {
-      throw new ConnectedAccountBillingError(
-        "The plan subscription is not active.",
-        "subscription_not_active",
-        402
-      );
-    }
-    if (!findBasePlanItem(subscription)) {
-      throw new ConnectedAccountBillingError(
-        "The base plan item could not be found on this subscription.",
-        "subscription_plan_item_missing",
-        409
+    if (actualQuantity > currentQuantity) {
+      const newConnections = actualQuantity - currentQuantity;
+      const feeMc = newConnections * CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC;
+      const debit = await debitMc(
+        user.id,
+        feeMc,
+        LedgerOperation.CONNECTED_ACCOUNT_FEE,
+        `${newConnections} connected account${newConnections === 1 ? "" : "s"} at ${CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS} credits/month`
       );
-    }
-    const currentQuantity = Math.max(0, currentItem?.quantity ?? 0);
-    let resultingItem = currentItem;
-    if (actualQuantity !== currentQuantity) {
-      const updated = await client2.subscriptions.update(subscription.id, {
-        items: actualQuantity === 0 ? currentItem ? [{ id: currentItem.id, deleted: true }] : [] : currentItem ? [{ id: currentItem.id, quantity: actualQuantity }] : [{ price: priceId, quantity: actualQuantity }],
-        proration_behavior: "create_prorations"
-      });
-      resultingItem = findConnectedAccountItem(updated, priceId);
+      if (!debit.ok) {
+        const requiredMc = feeMc;
+        const error = new ConnectedAccountBillingError(
+          `Insufficient credits to connect. Balance: ${mcToCredits(debit.balance_mc)} credits. Connecting requires ${mcToCredits(requiredMc)} credits (${mcToCredits(requiredMc - debit.balance_mc)} short). Upgrade your plan or wait for your credits to refresh.`,
+          "insufficient_credits",
+          402,
+          {
+            balanceCredits: mcToCredits(debit.balance_mc),
+            requiredCredits: mcToCredits(requiredMc),
+            shortByCredits: mcToCredits(Math.max(0, requiredMc - debit.balance_mc))
+          }
+        );
+        await persistFailure(user, currentQuantity, error);
+        throw error;
+      }
     }
     const state = await setConnectedAccountBillingState({
       userId: user.id,
-      stripeSubscriptionId: subscription.id,
-      stripeSubscriptionItemId: resultingItem?.id ?? null,
+      stripeSubscriptionId: user.subscription_id,
+      stripeSubscriptionItemId: null,
       priceId,
       quantity: actualQuantity,
       status: "synced",
@@ -19775,10 +19980,10 @@ async function reconcileConnectedAccountBilling(user, actualQuantity, stripeClie
     });
     return connectedAccountBillingView(actualQuantity, state);
   } catch (error) {
-    await persistFailure(user, actualQuantity, error, currentItem?.id ?? null);
     if (error instanceof ConnectedAccountBillingError) throw error;
+    await persistFailure(user, currentQuantity, error);
     throw new ConnectedAccountBillingError(
-      "Unable to update connected-account billing in Stripe.",
+      "Unable to update connected-account billing.",
       "stripe_connection_billing_failed",
       503
     );
@@ -19789,7 +19994,7 @@ async function currentConnectedAccountBillingView(userId, actualQuantity) {
 }
 
 // src/api/stripe-routes.ts
-var stripe = new Stripe2(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
+var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
 var stripeApp = new Hono19();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
@@ -19818,17 +20023,41 @@ stripeApp.post("/webhooks", async (c) => {
       if (tier) {
         const user = await resolveUser2(invoice.customer, invoice.customer_email ?? void 0);
         if (user && invoice.id && !await ledgerExistsForStripePI(invoice.id)) {
-          await creditMc(user.id, tier.credits_mc, LedgerOperation.SUBSCRIPTION, `${tier.label} subscription credits`, invoice.id);
+          await creditMc(user.id, tier.credits_mc, LedgerOperation.SUBSCRIPTION, `${tier.label} subscription credits`, invoice.id, { neverExpires: tier.credits_never_expire });
           await setSubscriptionTier(user.id, tier.tier, tier.concurrency, subId ?? user.subscription_id);
+          if (tier.includes_memory) {
+            const subscriptionId = subId ?? user.subscription_id;
+            await setMemoryPlan(user.id, "pro", subscriptionId ?? null);
+            await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, memory_plan: "pro" }));
+          }
           const credentials = await syncScheduledActionCredentials(user);
           if (!credentials.ok) console.warn("[stripe] scheduled-action credential sync failed:", credentials.error ?? "unknown error");
+          const connectionState = await getConnectedAccountBillingState(user.id);
+          const activeConnections = Math.max(0, connectionState?.quantity ?? 0);
+          if (activeConnections > 0) {
+            const feeMc = activeConnections * CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC;
+            const feeDescription = `${activeConnections} connected account${activeConnections === 1 ? "" : "s"} renewal at ${CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS} credits/month`;
+            const feeDebit = await debitMcIdempotent(user.id, feeMc, LedgerOperation.CONNECTED_ACCOUNT_FEE, feeDescription, `connection-fee:${invoice.id}`);
+            if (!feeDebit.ok) {
+              await setConnectedAccountBillingState({
+                userId: user.id,
+                stripeSubscriptionId: user.subscription_id,
+                stripeSubscriptionItemId: null,
+                priceId: connectionState?.price_id ?? null,
+                quantity: activeConnections,
+                status: "blocked",
+                lastErrorCode: "insufficient_credits",
+                synced: false
+              });
+            }
+          }
         }
       }
     }
   }
   if (event.type === "customer.subscription.created" || event.type === "customer.subscription.updated") {
     const sub = event.data.object;
-    const priceId = sub.items.data[0]?.price?.id;
+    const priceId = findBasePlanItem(sub)?.price?.id ?? sub.items.data[0]?.price?.id;
     if (priceId && priceId in MEMORY_PLANS) {
       const mem = MEMORY_PLANS[priceId];
       const user2 = await resolveUser2(sub.customer, sub.customer_email);
@@ -19847,6 +20076,14 @@ stripeApp.post("/webhooks", async (c) => {
       const live = sub.status === "active" || sub.status === "trialing";
       const newTier = live ? tier.tier : null;
       await setSubscriptionTier(user.id, newTier, live ? tier.concurrency : 0, live ? sub.id : null);
+      if (tier.includes_memory) {
+        const newMemoryPlan = live ? "pro" : "free";
+        await setMemoryPlan(user.id, newMemoryPlan, live ? sub.id : null);
+        await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, memory_plan: newMemoryPlan }));
+      } else if (user.memory_subscription_id === sub.id) {
+        await setMemoryPlan(user.id, "free", null);
+        await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, memory_plan: "free" }));
+      }
       if (live) {
         const credentials = await syncScheduledActionCredentials(user);
         if (!credentials.ok) console.warn("[stripe] scheduled-action credential sync failed:", credentials.error ?? "unknown error");
@@ -19858,7 +20095,19 @@ stripeApp.post("/webhooks", async (c) => {
   }
   if (event.type === "customer.subscription.deleted") {
     const sub = event.data.object;
-    const priceId = sub.items.data[0]?.price?.id;
+    const priceId = findBasePlanItem(sub)?.price?.id ?? sub.items.data[0]?.price?.id;
+    if (priceId && priceId in SUBSCRIPTION_TIERS) {
+      const tier = SUBSCRIPTION_TIERS[priceId];
+      const user2 = await getUserByStripeCustomerId(sub.customer);
+      if (user2) {
+        await setSubscriptionTier(user2.id, null, 0, null);
+        if (tier.includes_memory || user2.memory_subscription_id === sub.id) {
+          await setMemoryPlan(user2.id, "free", null);
+          await syncMemoryKeyPlan(user2, resolveEffectiveMemoryPlan({ ...user2, memory_plan: "free" }));
+        }
+      }
+      return c.json({ received: true });
+    }
     if (priceId && priceId in MEMORY_PLANS || await resolveUserByMemorySubscription(sub.id)) {
       const user2 = await resolveUserByMemorySubscription(sub.id) ?? await getUserByStripeCustomerId(sub.customer);
       if (user2) {
@@ -19869,9 +20118,7 @@ stripeApp.post("/webhooks", async (c) => {
     }
     const user = await getUserByStripeCustomerId(sub.customer);
     if (!user) return c.json({ received: true });
-    if (priceId && priceId in SUBSCRIPTION_TIERS) {
-      await setSubscriptionTier(user.id, null, 0, null);
-    } else if (priceId === CONCURRENCY_PRICE_ID) {
+    if (priceId === CONCURRENCY_PRICE_ID) {
       await setExtraConcurrencySlots(user.id, Math.max(0, user.extra_concurrency_slots - 1));
       await setConcurrencySubId(user.id, null);
     }
@@ -19964,9 +20211,9 @@ function negotiateScope(requested, user, resource) {
   const filtered = wanted.filter((s) => MEMORY_SCOPES.includes(s));
   const base = filtered.length > 0 ? filtered : ["memory.read", "memory.write"];
   const allowed = base.filter((s) => s === "memory.admin" ? operator : true);
-  const unique = [...new Set(allowed)];
-  if (operator && !unique.includes("memory.admin")) unique.push("memory.admin");
-  return unique.join(" ");
+  const unique2 = [...new Set(allowed)];
+  if (operator && !unique2.includes("memory.admin")) unique2.push("memory.admin");
+  return unique2.join(" ");
 }
 async function sessionUser(token) {
   if (!token) return null;
@@ -21688,50 +21935,262 @@ loadActions();
 // src/api/resend-inbound-routes.ts
 import { Hono as Hono24 } from "hono";
 import { Resend } from "resend";
-var SUPPORT_ADDRESS = "support@mcpscraper.dev";
-var DMARC_ADDRESS = "dmarc@mcpscraper.dev";
-var FORWARD_FROM = "MCP Scraper Support <support@updates.mcpscraper.dev>";
-function classifyInboundRecipients(recipients, ...receivingDomains) {
-  const normalized = recipients.map((address) => address.trim().toLowerCase());
-  const domains = receivingDomains.map((domain) => domain?.trim().toLowerCase()).filter((domain) => Boolean(domain));
-  const supportAddresses = [SUPPORT_ADDRESS, ...domains.map((domain) => `support@${domain}`)];
-  const dmarcAddresses = [DMARC_ADDRESS, ...domains.map((domain) => `dmarc@${domain}`)];
-  if (supportAddresses.some((address) => normalized.includes(address))) return "support";
-  if (dmarcAddresses.some((address) => normalized.includes(address))) return "dmarc";
-  return "ignore";
-}
-function cleanLine(value, fallback) {
-  const clean2 = value.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim();
-  return (clean2 || fallback).slice(0, 240);
+
+// src/api/resend-support-thread.ts
+import { createHash as createHash7 } from "crypto";
+var SUPPORT_TAGS = [
+  {
+    tag: "support",
+    central: true,
+    reusable: true,
+    description: "Customer support work, context, and follow-up."
+  },
+  {
+    tag: "customer-support",
+    central: true,
+    reusable: true,
+    description: "Inbound and in-product MCP Scraper customer support requests."
+  },
+  {
+    tag: "inbound-email",
+    central: true,
+    reusable: true,
+    description: "Messages received through an inbound email integration."
+  }
+];
+var ISSUE_TAGS = [
+  ...SUPPORT_TAGS,
+  {
+    tag: "product-feedback",
+    central: true,
+    reusable: true,
+    description: "Customer feedback and reported product problems."
+  }
+];
+function cleanLine(value, fallback, max = 240) {
+  const clean2 = String(value ?? "").replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim();
+  return (clean2 || fallback).slice(0, max);
 }
 function quoteUntrusted(value) {
-  const clean2 = value.replace(/\0/g, "").trim().slice(0, 16e3);
+  const clean2 = String(value ?? "").replace(/\0/g, "").trim().slice(0, 16e3);
   if (!clean2) return "> _(No plain-text body was available. Review the forwarded email.)_";
   return clean2.split("\n").map((line) => `> ${line}`).join("\n");
 }
-function escapeHtml2(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+function shortHash(value, length = 24) {
+  return createHash7("sha256").update(value).digest("hex").slice(0, length);
 }
-function safeEmailId(value) {
-  return value.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 100) || "unknown-email";
+function safePathPart(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "contact";
 }
-function buildSupportIssueNote(email) {
-  const sender = cleanLine(email.from, "unknown sender");
-  const subject = cleanLine(email.subject, "(no subject)");
-  const receivedAt = cleanLine(email.created_at, (/* @__PURE__ */ new Date()).toISOString());
-  const attachments = email.attachments?.length ? email.attachments.map((item) => cleanLine(item.filename ?? "unnamed attachment", "unnamed attachment")).join(", ") : "None";
-  const datePrefix = receivedAt.slice(0, 10).replace(/[^0-9-]/g, "") || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const path5 = `support/inbound/${datePrefix}-${safeEmailId(email.id)}`;
-  const title = `Support email \u2014 ${subject} \u2014 ${sender}`.slice(0, 240);
-  const summary = `Inbound MCP Scraper support email from ${sender} about \u201C${subject}\u201D; awaiting review and response.`.slice(0, 500);
+function parseMailbox(value) {
+  const raw = cleanLine(value, "", 500);
+  if (!raw) return null;
+  const angle = raw.match(/^(.*?)<([^<>]+)>$/);
+  const candidate = (angle?.[2] ?? raw).trim().toLowerCase();
+  const emailMatch = candidate.match(/[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?/i);
+  if (!emailMatch) return null;
+  const email = emailMatch[0].toLowerCase();
+  const suppliedName = angle?.[1]?.trim().replace(/^["']|["']$/g, "");
+  return { email, name: cleanLine(suppliedName, email) };
+}
+function supportSender(email) {
+  return parseMailbox(email.reply_to?.[0]) ?? parseMailbox(email.from);
+}
+function normalizeSupportSubject(value) {
+  let subject = cleanLine(value, "(no subject)", 240);
+  for (let i = 0; i < 8; i += 1) {
+    const next = subject.replace(/^\[(?:support|external)\]\s*/i, "").replace(/^(?:re|fw|fwd)\s*:\s*/i, "").trim();
+    if (next === subject) break;
+    subject = next;
+  }
+  return subject || "(no subject)";
+}
+function supportThreadToken(customerEmail, normalizedSubject) {
+  return shortHash(`${customerEmail.trim().toLowerCase()}
+${normalizeSupportSubject(normalizedSubject).toLowerCase()}`);
+}
+function supportThreadAddress(token, receivingDomain) {
+  const safeToken = token.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
+  const domain = receivingDomain.trim().toLowerCase();
+  if (!safeToken || !/^[a-z0-9.-]+\.[a-z]{2,}$/i.test(domain)) throw new Error("invalid support thread address");
+  return `support+${safeToken}@${domain}`;
+}
+function isAutomatedMailbox(email) {
+  const local = email.toLowerCase().split("@", 1)[0];
+  return /^(?:no-?reply|do-?not-?reply|mailer-daemon|postmaster|dmarc|bounce|notifications?)$/.test(local);
+}
+function extractReplyText(value) {
+  const text2 = String(value ?? "").replace(/\0/g, "").trim();
+  if (!text2) return "";
+  const lines = text2.split(/\r?\n/);
+  const kept = [];
+  for (const line of lines) {
+    if (/^On .+ wrote:\s*$/i.test(line.trim())) break;
+    if (/^-{2,}\s*Forwarded message\s*-{2,}$/i.test(line.trim())) break;
+    if (/^From:\s+MCP Scraper Support\b/i.test(line.trim())) break;
+    if (/^>\s?/.test(line)) break;
+    kept.push(line);
+  }
+  return kept.join("\n").trim().slice(0, 16e3);
+}
+function personPath(identity) {
+  const local = identity.email.split("@")[0];
+  return `contacts/${safePathPart(identity.name === identity.email ? local : identity.name)}-${shortHash(identity.email, 12)}`;
+}
+function issuePath(token) {
+  return `support/threads/${token}`;
+}
+function communicationPath(email) {
+  const date = cleanLine(email.created_at, (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10).replace(/[^0-9-]/g, "");
+  const id = email.id.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 100) || shortHash(email.message_id || email.id);
+  return `Email/${date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}-${id}`;
+}
+function noteRef(vault, path5) {
+  return `${vault}::${path5.replace(/\.md$/i, "")}.md`;
+}
+function unique(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.trim().length > 0))];
+}
+function searchPath(source) {
+  if (!source?.startsWith("note:")) return null;
+  const path5 = source.slice("note:".length).trim();
+  return path5 || null;
+}
+async function getNote(memoryKey, vault, path5) {
+  const result = await memoryCall("getTool", { vault, path: path5 }, memoryKey);
+  return result.ok && result.note ? result.note : null;
+}
+async function inspectTagVocabulary(memoryKey) {
+  const result = await memoryCall("listTagsTool", {}, memoryKey);
+  if (!result.ok) throw new Error(result.error ?? "tag vocabulary could not be inspected");
+}
+async function captureNewNote(memoryKey, input) {
+  const existing = await getNote(memoryKey, input.vault, input.path);
+  if (existing) return existing;
+  const prepared = await memoryCall("prepareMemoryWriteTool", {
+    title: input.title,
+    content: input.content,
+    source: input.source,
+    type: input.type,
+    vault: input.vault,
+    tagCandidates: input.tagCandidates,
+    maxLinks: 4
+  }, memoryKey);
+  if (!prepared.ok) throw new Error(prepared.error ?? `${input.vault} memory preparation failed`);
+  const resolvedTags = unique(
+    (prepared.tagResolutions ?? []).filter((item) => item.action !== "omit").map((item) => item.tag ?? item.candidate)
+  );
+  const capture = await memoryCall("memoryCaptureTool", {
+    vault: input.vault,
+    path: input.path,
+    title: input.title,
+    content: input.content,
+    props: { ...input.props, tags: resolvedTags },
+    tagDecisions: input.tagCandidates
+  }, memoryKey);
+  if (!capture.ok && !capture.conflict) {
+    const detail = JSON.stringify(capture);
+    throw new Error(`${capture.error ?? `${input.vault} memory capture failed`}: ${detail.slice(0, 2e3)}`);
+  }
+  const stored = await getNote(memoryKey, input.vault, input.path);
+  if (!stored) throw new Error(`${input.vault} memory capture could not be read back`);
+  return stored;
+}
+async function findOrCreatePerson(memoryKey, customer, occurredAt) {
+  const result = await memoryCall("searchTool", {
+    vault: "People",
+    query: customer.email,
+    queries: [
+      customer.email,
+      `contact ${customer.email}`,
+      `support relationship ${customer.email}`
+    ],
+    metadata: { email: customer.email },
+    rerankTopN: 10
+  }, memoryKey);
+  if (!result.ok) throw new Error(result.error ?? "People lookup failed");
+  for (const candidate of result.results ?? []) {
+    const path6 = searchPath(candidate.source);
+    if (!path6 || candidate.vault !== "People") continue;
+    const note = await getNote(memoryKey, "People", path6);
+    if (note && String(note.props?.email ?? "").toLowerCase() === customer.email) return note;
+  }
+  const path5 = personPath(customer);
+  const existing = await getNote(memoryKey, "People", path5);
+  if (existing) return existing;
+  const title = customer.name === customer.email ? customer.email : `${customer.name} \u2014 ${customer.email}`;
+  const summary = `MCP Scraper support contact identified by the verified sender email ${customer.email}.`;
   const content = [
+    "## Identity",
+    "",
+    `- Name: ${customer.name}`,
+    `- Email: ${customer.email}`,
+    "",
+    "## Relationship",
+    "",
+    "MCP Scraper support contact. The relationship is not classified beyond the verified email exchange.",
+    "",
+    "## Known Context",
+    "",
+    "This person contacted MCP Scraper support. Durable facts should be added only after review.",
+    "",
+    "## Interaction History",
+    "",
+    "Linked Communication records provide the message history.",
+    "",
+    "## Open Loops",
+    "",
+    "Review the linked support thread and respond if needed.",
+    "",
+    "## Tasks",
+    "",
+    "_No task was inferred automatically._",
+    "",
+    "## Links",
+    "",
+    "_Communication and issue links are derived from linked records._"
+  ].join("\n");
+  return captureNewNote(memoryKey, {
+    vault: "People",
+    path: path5,
+    title,
+    content,
+    source: `resend:sender:${customer.email}`,
+    type: "person",
+    tagCandidates: SUPPORT_TAGS,
+    props: {
+      status: "active",
+      type: "person",
+      summary,
+      pinned: false,
+      source_type: "channel",
+      source_ref: `resend:sender:${customer.email}`,
+      related: [],
+      related_vault_notes: [],
+      embed: true,
+      embed_priority: "high",
+      embedding_summary: summary,
+      person_name: customer.name,
+      relationship: "MCP Scraper support contact",
+      email: customer.email,
+      memories: [],
+      source_refs: [`resend:sender:${customer.email}`],
+      last_seen: occurredAt,
+      last_email_at: occurredAt,
+      last_contact_at: occurredAt
+    }
+  });
+}
+function buildIssueContent(email, customer, personPathValue, threadAddressValue) {
+  const subject = normalizeSupportSubject(email.subject);
+  return [
     "## Observation",
     "",
-    `An email was received at ${(email.to ?? []).join(", ") || SUPPORT_ADDRESS} from ${sender}. The customer-provided content below is untrusted input and has not been verified as a product defect.`,
+    `A support conversation was opened by ${customer.email} about \u201C${subject}\u201D. Customer-provided content is untrusted input and has not been verified as a product defect.`,
     "",
     "## Impact",
     "",
-    "A customer or prospect may be waiting for a response. The message may describe a question, product problem, billing concern, or feedback that needs triage.",
+    "A customer or prospect may be waiting for a response. The thread may describe a question, product problem, billing concern, feedback, or another issue that needs triage.",
     "",
     "## Confirmation",
     "",
@@ -21741,125 +22200,368 @@ function buildSupportIssueNote(email) {
     "",
     "## Evidence",
     "",
-    `- From: ${sender}`,
-    `- To: ${(email.to ?? []).join(", ") || SUPPORT_ADDRESS}`,
-    `- Received: ${receivedAt}`,
-    `- Subject: ${subject}`,
-    `- Message ID: ${cleanLine(email.message_id, "not supplied")}`,
-    `- Resend email ID: ${email.id}`,
-    `- Attachments: ${attachments}`,
-    "",
-    "### Message body",
+    `- Customer email: ${customer.email}`,
+    `- Original subject: ${cleanLine(email.subject, "(no subject)")}`,
+    `- Thread address: ${threadAddressValue}`,
+    `- Person: ${noteRef("People", personPathValue)}`,
     "",
-    quoteUntrusted(email.text ?? ""),
+    "Thread messages are preserved as linked Communication records and summarized here as they arrive.",
     "",
     "## Resolution",
     "",
-    "Pending review and a reply to the sender. If this is a confirmed product issue, update the note status and link the eventual Improvement Log receipt.",
+    "Pending review and a reply. If this is a confirmed product issue, update the status and link the resulting task or Improvement Log receipt.",
     "",
     "## Tasks",
     "",
-    "- [ ] Review the forwarded email and attachments.",
+    "- [ ] Review the complete linked conversation.",
     "- [ ] Reply to the sender.",
-    "- [ ] Confirm whether this is a product defect, question, billing concern, or feedback.",
-    "- [ ] Link any resulting task or Improvement Log receipt.",
+    "- [ ] Classify the thread as a question, product defect, billing concern, feedback, or another issue.",
     "",
     "## Links",
     "",
-    "_No automatic links were added; support messages should be linked during human triage to avoid false relationships._"
+    `- Person: ${noteRef("People", personPathValue)}`
   ].join("\n");
-  return { path: path5, title, content, summary };
-}
-async function captureSupportIssue(email, memoryKey) {
-  const note = buildSupportIssueNote(email);
-  const tagCandidates = [
-    { tag: "customer-support", central: true, reusable: true, description: "Inbound and in-product MCP Scraper customer support requests." },
-    { tag: "inbound-email", central: true, reusable: true, description: "Messages received through an inbound email integration." },
-    { tag: "product-feedback", central: true, reusable: true, description: "Customer feedback and reported product problems." }
-  ];
-  const prepared = await memoryCall("prepareMemoryWriteTool", {
-    title: note.title,
-    content: note.content,
-    source: `resend:email:${email.id}`,
-    type: "user_friction",
-    vault: "Issues",
-    tagCandidates,
-    maxLinks: 4
-  }, memoryKey);
-  if (!prepared.ok) throw new Error(prepared.error ?? "memory preparation failed");
-  const resolvedTags = (prepared.tagResolutions ?? []).filter((item) => item.action !== "omit").map((item) => item.tag ?? item.candidate).filter((tag) => Boolean(tag));
-  const capture = await memoryCall("memoryCaptureTool", {
+}
+async function findOrCreateIssue(memoryKey, email, customer, personPathValue, token, threadAddressValue) {
+  const path5 = issuePath(token);
+  const existing = await getNote(memoryKey, "Issues", path5);
+  if (existing) return existing;
+  const subject = normalizeSupportSubject(email.subject);
+  const summary = `Support conversation with ${customer.email} about \u201C${subject}\u201D; full history is linked through Communication records.`;
+  return captureNewNote(memoryKey, {
     vault: "Issues",
-    path: note.path,
-    title: note.title,
-    content: note.content,
+    path: path5,
+    title: `Support thread \u2014 ${subject} \u2014 ${customer.email}`.slice(0, 240),
+    content: buildIssueContent(email, customer, personPathValue, threadAddressValue),
+    source: `resend:thread:${token}`,
+    type: "user_friction",
+    tagCandidates: ISSUE_TAGS,
     props: {
       status: "ai_observed",
-      summary: note.summary,
-      tags: resolvedTags,
+      type: "user_friction",
+      summary,
       pinned: false,
-      source_type: "channel",
-      source_ref: `resend:email:${email.id}`,
+      source_type: "thread",
+      source_ref: `resend:thread:${token}`,
       related: [],
-      related_vault_notes: [],
+      related_vault_notes: [noteRef("People", personPathValue)],
       embed: true,
       embed_priority: "high",
-      embedding_summary: note.summary,
-      type: "user_friction",
+      embedding_summary: summary,
       severity: "untriaged",
       system: "MCP Scraper customer support",
       observed_at: email.created_at,
       detected_by: "resend-email-webhook",
-      reproducible: false
+      reproducible: false,
+      person_refs: [personPathValue],
+      customer_email: customer.email,
+      customer_name: customer.name,
+      normalized_subject: subject,
+      thread_token: token,
+      thread_address: threadAddressValue,
+      communication_refs: [],
+      message_count: 0,
+      attention_state: "needs_reply"
+    }
+  });
+}
+function buildCommunicationContent(email, customer, direction, personPathValue, issuePathValue, parentPath) {
+  const sender = supportSender(email);
+  const body = direction === "outbound" ? extractReplyText(email.text) : email.text;
+  const participants = direction === "inbound" ? `- From: ${sender?.email ?? email.from}
+- To: MCP Scraper support` : `- From: MCP Scraper support
+- To: ${customer.email}`;
+  return [
+    "## Summary",
+    "",
+    `${direction === "inbound" ? "Inbound" : "Outbound"} support email in the \u201C${normalizeSupportSubject(email.subject)}\u201D thread.`,
+    "",
+    "## Participants",
+    "",
+    participants,
+    `- Person: ${noteRef("People", personPathValue)}`,
+    "",
+    "## Message",
+    "",
+    quoteUntrusted(body),
+    "",
+    "## Decision",
+    "",
+    "_No decision was inferred automatically._",
+    "",
+    "## Follow Up Tasks",
+    "",
+    direction === "inbound" ? "- [ ] Review and reply." : "- [ ] Wait for the customer response or close the thread after review.",
+    "",
+    "## Links",
+    "",
+    `- Issue: ${noteRef("Issues", issuePathValue)}`,
+    `- Person: ${noteRef("People", personPathValue)}`,
+    ...parentPath ? [`- Previous message: [[${parentPath}]]`] : []
+  ].join("\n");
+}
+async function captureCommunication(memoryKey, email, customer, direction, personPathValue, issuePathValue, token, parentPath) {
+  const path5 = communicationPath(email);
+  const existing = await getNote(memoryKey, "Communication", path5);
+  if (existing) return existing;
+  const subject = normalizeSupportSubject(email.subject);
+  const summary = `${direction === "inbound" ? "Inbound message from" : "Outbound reply to"} ${customer.email} in the support thread about \u201C${subject}\u201D.`;
+  const providerMessageRef = cleanLine(email.message_id, email.id, 500);
+  return captureNewNote(memoryKey, {
+    vault: "Communication",
+    path: path5,
+    title: `${direction === "inbound" ? "Inbound" : "Outbound"} email \u2014 ${subject} \u2014 ${customer.email}`.slice(0, 240),
+    content: buildCommunicationContent(email, customer, direction, personPathValue, issuePathValue, parentPath),
+    source: `resend:email:${email.id}`,
+    type: "email",
+    tagCandidates: SUPPORT_TAGS,
+    props: {
+      status: direction === "inbound" ? "inbox" : "responded",
+      type: "email",
+      summary,
+      pinned: false,
+      source_type: "channel",
+      source_ref: `resend:email:${email.id}`,
+      related: parentPath ? [`[[${parentPath}]]`] : [],
+      related_vault_notes: [
+        noteRef("People", personPathValue),
+        noteRef("Issues", issuePathValue)
+      ],
+      embed: true,
+      embed_priority: "high",
+      embedding_summary: summary,
+      channel: "email",
+      participants: [customer.email, "support@updates.mcpscraper.dev"],
+      person_refs: [personPathValue],
+      occurred_at: email.created_at,
+      direction,
+      attention_state: direction === "inbound" ? "needs_reply" : "waiting",
+      provider: "resend",
+      provider_connection_ref: "resend:updates.mcpscraper.dev",
+      provider_message_ref: providerMessageRef,
+      provider_thread_ref: token,
+      thread_ref: token,
+      issue_ref: issuePathValue,
+      sender_email: supportSender(email)?.email ?? email.from,
+      recipient_emails: email.to ?? [],
+      parentMessageId: parentPath,
+      parent_communication_ref: parentPath
+    }
+  });
+}
+function appendIssueEvidence(content, email, communicationPathValue, direction) {
+  const marker = `- Resend email ID: ${email.id}`;
+  if (content.includes(marker)) return content;
+  const block = [
+    `### ${direction === "inbound" ? "Inbound" : "Outbound"} email \u2014 ${cleanLine(email.created_at, (/* @__PURE__ */ new Date()).toISOString())}`,
+    "",
+    `- Communication: ${noteRef("Communication", communicationPathValue)}`,
+    `- Subject: ${cleanLine(email.subject, "(no subject)")}`,
+    marker,
+    `- Message ID: ${cleanLine(email.message_id, "not supplied", 500)}`,
+    "",
+    quoteUntrusted(direction === "outbound" ? extractReplyText(email.text) : email.text),
+    ""
+  ].join("\n");
+  const anchor = "\n## Resolution";
+  return content.includes(anchor) ? content.replace(anchor, `
+${block}${anchor}`) : `${content}
+
+${block}`;
+}
+async function updateIssueThread(memoryKey, issuePathValue, email, communicationPathValue, direction, personPathValue) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const current = await getNote(memoryKey, "Issues", issuePathValue);
+    if (!current) throw new Error("support thread issue disappeared before update");
+    const currentRefs = unique(Array.isArray(current.props?.communication_refs) ? current.props.communication_refs : []);
+    const alreadyLinked = currentRefs.includes(communicationPathValue);
+    const communicationRefs = alreadyLinked ? currentRefs : [...currentRefs, communicationPathValue];
+    const relatedVaultNotes = unique([
+      ...Array.isArray(current.props?.related_vault_notes) ? current.props.related_vault_notes : [],
+      noteRef("People", personPathValue),
+      ...communicationRefs.map((path5) => noteRef("Communication", path5))
+    ]);
+    const result = await memoryCall("putTool", {
+      vault: "Issues",
+      path: issuePathValue,
+      title: current.title,
+      content: appendIssueEvidence(current.content, email, communicationPathValue, direction),
+      baseRevision: current.revision,
+      props: {
+        related_vault_notes: relatedVaultNotes,
+        communication_refs: communicationRefs,
+        last_communication_ref: communicationPathValue,
+        last_message_at: email.created_at,
+        message_count: communicationRefs.length,
+        attention_state: direction === "inbound" ? "needs_reply" : "waiting"
+      }
+    }, memoryKey);
+    if (result.ok) return;
+    if (!result.conflict || attempt === 1) throw new Error(result.error ?? "support thread issue update failed");
+  }
+}
+async function getSupportThreadByToken(memoryKey, token) {
+  const safeToken = token.toLowerCase().replace(/[^a-f0-9]/g, "").slice(0, 24);
+  if (safeToken.length !== 24) return null;
+  const path5 = issuePath(safeToken);
+  const issue = await getNote(memoryKey, "Issues", path5);
+  if (!issue) return null;
+  const customerEmail = parseMailbox(String(issue.props?.customer_email ?? ""));
+  const personRefs = Array.isArray(issue.props?.person_refs) ? issue.props.person_refs : [];
+  const personPathValue = personRefs.find((value) => typeof value === "string");
+  const threadAddressValue = String(issue.props?.thread_address ?? "");
+  if (!customerEmail || !personPathValue || !threadAddressValue) return null;
+  return {
+    issue,
+    issuePath: path5,
+    threadToken: safeToken,
+    threadAddress: threadAddressValue,
+    customer: {
+      email: customerEmail.email,
+      name: cleanLine(String(issue.props?.customer_name ?? ""), customerEmail.email)
     },
-    tagDecisions: tagCandidates
-  }, memoryKey);
-  if (capture.ok) return capture.note?.path ?? note.path;
-  if (capture.conflict) {
-    const existing = await memoryCall("getTool", { vault: "Issues", path: note.path }, memoryKey);
-    if (existing.ok) return note.path;
+    personPath: personPathValue,
+    normalizedSubject: cleanLine(String(issue.props?.normalized_subject ?? ""), "(no subject)")
+  };
+}
+async function captureSupportMessage(memoryKey, email, options) {
+  await inspectTagVocabulary(memoryKey);
+  const customer = options.customer ?? supportSender(email);
+  if (!customer) throw new Error("support sender does not contain a usable email address");
+  const normalizedSubject = options.existingThread?.normalizedSubject ?? normalizeSupportSubject(email.subject);
+  const token = options.existingThread?.threadToken ?? supportThreadToken(customer.email, normalizedSubject);
+  const threadAddressValue = options.existingThread?.threadAddress ?? supportThreadAddress(token, options.receivingDomain);
+  const person = options.existingThread ? await getNote(memoryKey, "People", options.existingThread.personPath) : await findOrCreatePerson(memoryKey, customer, email.created_at);
+  if (!person) throw new Error("support person could not be resolved");
+  const issue = options.existingThread?.issue ?? await findOrCreateIssue(
+    memoryKey,
+    email,
+    customer,
+    person.path,
+    token,
+    threadAddressValue
+  );
+  const parentPath = typeof issue.props?.last_communication_ref === "string" ? issue.props.last_communication_ref : void 0;
+  const communication = await captureCommunication(
+    memoryKey,
+    email,
+    customer,
+    options.direction,
+    person.path,
+    issue.path,
+    token,
+    parentPath
+  );
+  await updateIssueThread(memoryKey, issue.path, email, communication.path, options.direction, person.path);
+  return {
+    issuePath: issue.path,
+    communicationPath: communication.path,
+    personPath: person.path,
+    parentCommunicationPath: parentPath,
+    threadToken: token,
+    threadAddress: threadAddressValue,
+    customerEmail: customer.email,
+    normalizedSubject,
+    direction: options.direction
+  };
+}
+
+// src/api/resend-inbound-routes.ts
+var SUPPORT_ADDRESS = "support@mcpscraper.dev";
+var DMARC_ADDRESS = "dmarc@mcpscraper.dev";
+var FORWARD_FROM = "MCP Scraper Support <support@updates.mcpscraper.dev>";
+function receivingDomains(values) {
+  return values.map((domain) => domain?.trim().toLowerCase()).filter((domain) => Boolean(domain));
+}
+function extractSupportThreadToken(recipients, ...domainsInput) {
+  const domains = receivingDomains(domainsInput);
+  for (const recipient of recipients) {
+    const address = parseMailbox(recipient)?.email ?? recipient.trim().toLowerCase();
+    const match = address.match(/^support\+([a-f0-9]{24})@(.+)$/i);
+    if (match && domains.includes(match[2].toLowerCase())) return match[1].toLowerCase();
   }
-  throw new Error(capture.error ?? "memory capture failed");
+  return null;
+}
+function classifyInboundRecipients(recipients, ...domainsInput) {
+  const normalized = recipients.map((address) => parseMailbox(address)?.email ?? address.trim().toLowerCase());
+  const domains = receivingDomains(domainsInput);
+  const supportAddresses = [SUPPORT_ADDRESS, ...domains.map((domain) => `support@${domain}`)];
+  const dmarcAddresses = [DMARC_ADDRESS, ...domains.map((domain) => `dmarc@${domain}`)];
+  if (dmarcAddresses.some((address) => normalized.includes(address))) return "dmarc";
+  if (extractSupportThreadToken(recipients, ...domains)) return "support-thread";
+  if (supportAddresses.some((address) => normalized.includes(address))) return "support";
+  return "ignore";
 }
-async function forwardReceivedEmail(resend, email, destination, label) {
+function escapeHtml2(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function safeEmailId(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 100) || "unknown-email";
+}
+async function receivedAttachments(resend, email) {
   const attachmentResult = await resend.emails.receiving.attachments.list({ emailId: email.id });
   if (attachmentResult.error) throw new Error(`attachment retrieval failed: ${attachmentResult.error.message}`);
-  const attachments = (attachmentResult.data?.data ?? []).filter((item) => item.content_disposition !== "inline").map((item) => ({
+  return (attachmentResult.data?.data ?? []).filter((item) => item.content_disposition !== "inline").map((item) => ({
     path: item.download_url,
     filename: item.filename ?? "attachment",
     contentId: item.content_id
   }));
-  const sender = email.reply_to?.[0] || email.from;
-  const subject = cleanLine(email.subject, "(no subject)");
+}
+async function forwardSupportEmail(resend, email, destination, threadAddress) {
+  const attachments = await receivedAttachments(resend, email);
+  const sender = supportSender(email);
+  const subject = normalizeSupportSubject(email.subject);
   const headerText = [
-    `${label} message received at ${(email.to ?? []).join(", ")}`,
+    `Support message received at ${(email.to ?? []).join(", ")}`,
     `From: ${email.from}`,
-    `Reply to: ${sender}`,
+    `Customer email: ${sender?.email ?? email.from}`,
     `Received: ${email.created_at}`,
+    `Thread reply address: ${threadAddress}`,
     ""
   ].join("\n");
   const headerHtml = [
     '<div style="font-family:Arial,sans-serif;font-size:13px;line-height:1.5;color:#5f5a54;border-bottom:1px solid #e9e4db;padding-bottom:12px;margin-bottom:18px">',
-    `<strong>${label} message received</strong><br>`,
+    "<strong>Support message received</strong><br>",
     `From: ${escapeHtml2(email.from)}<br>`,
-    `Reply to: ${escapeHtml2(sender)}<br>`,
-    `Received: ${escapeHtml2(email.created_at)}`,
+    `Customer email: ${escapeHtml2(sender?.email ?? email.from)}<br>`,
+    `Received: ${escapeHtml2(email.created_at)}<br>`,
+    `Thread reply address: ${escapeHtml2(threadAddress)}`,
     "</div>"
   ].join("");
   const sent = await resend.emails.send({
     from: FORWARD_FROM,
     to: destination,
-    replyTo: sender,
-    subject: `[${label}] ${subject}`,
+    replyTo: threadAddress,
+    subject: `[Support] ${subject}`,
     text: `${headerText}${email.text || "(HTML-only message; view the HTML version.)"}`,
     html: email.html ? `${headerHtml}${email.html}` : void 0,
     attachments: attachments.length ? attachments : void 0,
+    headers: { "X-MCP-Support-Thread": threadAddress },
     tags: [
-      { name: "category", value: label === "Support" ? "support_forward" : "dmarc_report" },
+      { name: "category", value: "support_forward" },
       { name: "inbound_id", value: safeEmailId(email.id) }
     ]
-  }, { idempotencyKey: `mcp-inbound-${label.toLowerCase()}-${safeEmailId(email.id)}` });
-  if (sent.error) throw new Error(`forward failed: ${sent.error.message}`);
+  }, { idempotencyKey: `mcp-inbound-support-${safeEmailId(email.id)}` });
+  if (sent.error) throw new Error(`support forward failed: ${sent.error.message}`);
+  return sent.data.id;
+}
+async function relayOperatorReply(resend, email, customerEmail, threadAddress, normalizedSubject) {
+  const attachments = await receivedAttachments(resend, email);
+  const replyText = extractReplyText(email.text) || "(No plain-text reply was available.)";
+  const sent = await resend.emails.send({
+    from: FORWARD_FROM,
+    to: customerEmail,
+    replyTo: threadAddress,
+    subject: `Re: ${normalizeSupportSubject(normalizedSubject)}`,
+    text: replyText,
+    attachments: attachments.length ? attachments : void 0,
+    headers: { "X-MCP-Support-Thread": threadAddress },
+    tags: [
+      { name: "category", value: "support_reply" },
+      { name: "inbound_id", value: safeEmailId(email.id) }
+    ]
+  }, { idempotencyKey: `mcp-support-reply-${safeEmailId(email.id)}` });
+  if (sent.error) throw new Error(`support reply relay failed: ${sent.error.message}`);
   return sent.data.id;
 }
 var resendInboundApp = new Hono24();
@@ -21885,32 +22587,99 @@ resendInboundApp.post("/webhooks", async (c) => {
   }
   if (event.type !== "email.received") return c.json({ ok: true, ignored: true });
   const receivedEvent = event;
-  const route = classifyInboundRecipients(
-    receivedEvent.data.to ?? [],
+  const domains = [
     process.env.RESEND_RECEIVING_DOMAIN,
     process.env.RESEND_MANAGED_RECEIVING_DOMAIN
-  );
-  if (route === "ignore") return c.json({ ok: true, ignored: true });
+  ];
+  const route = classifyInboundRecipients(receivedEvent.data.to ?? [], ...domains);
+  if (route === "ignore") return c.json({ ok: true, route, ignored: true });
+  if (route === "dmarc") {
+    return c.json({ ok: true, route, ignored: true, reason: "dmarc-report-suppressed" });
+  }
   const received = await resend.emails.receiving.get(receivedEvent.data.email_id);
   if (received.error || !received.data) {
     console.error("[resend/inbound] could not retrieve received email", receivedEvent.data.email_id);
     return c.json({ error: "received email could not be retrieved" }, 502);
   }
+  const destination = process.env.SUPPORT_FORWARD_TO?.trim();
+  const memoryKey = process.env.SUPPORT_INBOX_MEMORY_KEY?.trim();
+  const receivingDomain = process.env.RESEND_RECEIVING_DOMAIN?.trim();
+  if (!destination || !memoryKey || !receivingDomain) {
+    return c.json({ error: "support routing is not configured" }, 503);
+  }
   try {
+    const email = received.data;
+    const sender = supportSender(email);
+    if (!sender || isAutomatedMailbox(sender.email)) {
+      return c.json({ ok: true, route, ignored: true, reason: "automated-or-unusable-sender" });
+    }
     if (route === "support") {
-      const destination2 = process.env.SUPPORT_FORWARD_TO?.trim();
-      const memoryKey = process.env.SUPPORT_INBOX_MEMORY_KEY?.trim();
-      if (!destination2 || !memoryKey) return c.json({ error: "support routing is not configured" }, 503);
-      const [forwardedId2, memoryPath] = await Promise.all([
-        forwardReceivedEmail(resend, received.data, destination2, "Support"),
-        captureSupportIssue(received.data, memoryKey)
-      ]);
-      return c.json({ ok: true, route, forwardedId: forwardedId2, memoryPath });
+      const captured = await captureSupportMessage(memoryKey, email, {
+        receivingDomain,
+        direction: "inbound",
+        customer: sender
+      });
+      const forwardedId = await forwardSupportEmail(resend, received.data, destination, captured.threadAddress);
+      return c.json({
+        ok: true,
+        route,
+        direction: "inbound",
+        forwardedId,
+        issuePath: captured.issuePath,
+        communicationPath: captured.communicationPath,
+        personPath: captured.personPath,
+        threadAddress: captured.threadAddress
+      });
+    }
+    const token = extractSupportThreadToken(receivedEvent.data.to ?? [], ...domains);
+    const thread = token ? await getSupportThreadByToken(memoryKey, token) : null;
+    if (!thread) return c.json({ ok: true, route, ignored: true, reason: "unknown-support-thread" });
+    const operator = parseMailbox(destination);
+    if (operator && sender.email === operator.email) {
+      const captured = await captureSupportMessage(memoryKey, email, {
+        receivingDomain,
+        direction: "outbound",
+        customer: thread.customer,
+        existingThread: thread
+      });
+      const relayedId = await relayOperatorReply(
+        resend,
+        received.data,
+        thread.customer.email,
+        captured.threadAddress,
+        thread.normalizedSubject
+      );
+      return c.json({
+        ok: true,
+        route,
+        direction: "outbound",
+        relayedId,
+        issuePath: captured.issuePath,
+        communicationPath: captured.communicationPath,
+        personPath: captured.personPath,
+        threadAddress: captured.threadAddress
+      });
+    }
+    if (sender.email === thread.customer.email) {
+      const captured = await captureSupportMessage(memoryKey, email, {
+        receivingDomain,
+        direction: "inbound",
+        customer: thread.customer,
+        existingThread: thread
+      });
+      const forwardedId = await forwardSupportEmail(resend, received.data, destination, captured.threadAddress);
+      return c.json({
+        ok: true,
+        route,
+        direction: "inbound",
+        forwardedId,
+        issuePath: captured.issuePath,
+        communicationPath: captured.communicationPath,
+        personPath: captured.personPath,
+        threadAddress: captured.threadAddress
+      });
     }
-    const destination = process.env.DMARC_FORWARD_TO?.trim() || process.env.SUPPORT_FORWARD_TO?.trim();
-    if (!destination) return c.json({ error: "DMARC routing is not configured" }, 503);
-    const forwardedId = await forwardReceivedEmail(resend, received.data, destination, "DMARC");
-    return c.json({ ok: true, route, forwardedId });
+    return c.json({ ok: true, route, ignored: true, reason: "unrecognized-thread-sender" });
   } catch (err) {
     console.error("[resend/inbound] processing failed", receivedEvent.data.email_id, err instanceof Error ? err.message : String(err));
     return c.json({ error: "inbound email processing failed" }, 502);
@@ -21953,16 +22722,16 @@ function startSiteAuditWorker() {
 // src/api/server.ts
 import { createMiddleware as createMiddleware3 } from "hono/factory";
 import { getCookie as getCookie2, setCookie as setCookie2, deleteCookie } from "hono/cookie";
-import Stripe3 from "stripe";
+import Stripe2 from "stripe";
 
 // src/api/page-diff.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash7("sha256").update(value).digest("hex");
+  return createHash8("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -22069,7 +22838,7 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -22099,7 +22868,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash8("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -22941,10 +23710,10 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash10, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash11, randomUUID as randomUUID12 } from "crypto";
 
 // src/api/main-nango-transport.ts
-import { createHash as createHash9, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID11 } from "crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
@@ -23536,7 +24305,7 @@ async function listNangoToolsDirect(identity, connectionId) {
   });
   const readTools = tools.filter((tool) => classifyTool(tool) === "read").map((tool) => tool.name);
   const actionTools = tools.filter((tool) => classifyTool(tool) === "action").map((tool) => tool.name);
-  const revision = createHash9("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const revision = createHash10("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
   await updateServiceConnectionTools(connection.id, readTools, actionTools, revision);
   const refreshed = await getOwnedServiceConnection(identity, connection.id);
   return { connection: refreshed ?? { ...connection, readTools, actionTools, toolRevision: revision }, tools };
@@ -23557,7 +24326,7 @@ async function callNangoToolDirect(args) {
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
   const requestId = args.requestId?.trim() || randomUUID11();
-  const idempotencyKey = `main-nango:${createHash9("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const idempotencyKey = `main-nango:${createHash10("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
   const startedAt = /* @__PURE__ */ new Date();
   const started = performance.now();
   let result;
@@ -23582,7 +24351,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : createHash9("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : createHash10("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -23619,7 +24388,7 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: createHash9("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: createHash10("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -24344,7 +25113,7 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   return data.connection.actionsEnabled === true;
 }
 async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey) {
-  const requestId = `main-connected-action:${createHash10("sha256").update(identity).update("\0").update(idempotencyKey?.trim() || randomUUID12()).digest("hex")}`;
+  const requestId = `main-connected-action:${createHash11("sha256").update(identity).update("\0").update(idempotencyKey?.trim() || randomUUID12()).digest("hex")}`;
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -24486,7 +25255,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash10("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash11("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -25072,7 +25841,7 @@ async function callResendExportPage(identity, input) {
 }
 
 // src/api/scheduler-integration-auth.ts
-import { createHash as createHash11, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash12, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
 var MAX_CLOCK_SKEW_MS = 5 * 60 * 1e3;
 var SchedulerIntegrationAuthError = class extends Error {
   code;
@@ -25088,7 +25857,7 @@ function signingSecret() {
   return secret2;
 }
 function schedulerIntegrationSignature(args) {
-  const bodyHash = createHash11("sha256").update(args.body).digest("hex");
+  const bodyHash = createHash12("sha256").update(args.body).digest("hex");
   return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
 ${args.path}
 ${args.timestamp}
@@ -25237,7 +26006,7 @@ var requirePaidSchedulingTier = createMiddleware3(async (c, next) => {
   return next();
 });
 var app = new Hono25();
-var STRIPE_API_VERSION2 = "2026-02-25.clover";
+var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
   if (secret2) return secret2;
@@ -25247,7 +26016,7 @@ function requireStripeSecret() {
 async function createSignupStripeCustomer(email) {
   const secret2 = requireStripeSecret();
   if (!secret2) return null;
-  const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+  const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
   const customer = await stripeClient.customers.create({
     email,
     description: "MCP Scraper free account",
@@ -25319,7 +26088,7 @@ app.post("/auth/register", requireAllowedOrigin, async (c) => {
     const user = await createUser(normalizedEmail, void 0, password, stripeCustomerId ?? void 0);
     if (stripeCustomerId) {
       try {
-        const stripeClient = new Stripe3(process.env.STRIPE_SECRET_KEY, { apiVersion: STRIPE_API_VERSION2 });
+        const stripeClient = new Stripe2(process.env.STRIPE_SECRET_KEY, { apiVersion: STRIPE_API_VERSION });
         await stripeClient.customers.update(stripeCustomerId, {
           metadata: {
             app: "mcp-scraper",
@@ -25387,7 +26156,7 @@ app.post("/account/delete", requireAllowedOrigin, sessionAuth, async (c) => {
   }
   const secret2 = requireStripeSecret();
   if (secret2 && user.stripe_customer_id) {
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     const subs = await stripeClient.subscriptions.list({ customer: user.stripe_customer_id, status: "all", limit: 100 });
     for (const sub of subs.data) {
       if (sub.status === "active" || sub.status === "trialing" || sub.status === "past_due") {
@@ -25712,7 +26481,7 @@ app.post("/memory/checkout", auth2, async (c) => {
     if (!priceId || !MEMORY_PLANS[priceId]) return c.json({ error: "Invalid priceId \u2014 must be a memory plan price." }, 400);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -25747,7 +26516,7 @@ app.post("/memory/portal", auth2, async (c) => {
     if (!user.stripe_customer_id) return c.json({ error: "No billing account yet \u2014 subscribe first." }, 409);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     const session = await stripeClient.billingPortal.sessions.create({
       customer: user.stripe_customer_id,
       return_url: `${appOrigin()}/memory`
@@ -25965,10 +26734,8 @@ app.post("/schedule-connections/session", auth2, requireIntegrationsTier, async
   if (!providerConfigKey) return c.json({ ok: false, error: "providerConfigKey is required." }, 400);
   try {
     if (providerConfigKey !== "resend") {
-      await reconcileConnectedAccountBilling(
-        user,
-        billableNangoConnectionCount(await getNangoConnections(user.email, { summaryOnly: true }))
-      );
+      const existingCount = billableNangoConnectionCount(await getNangoConnections(user.email, { summaryOnly: true }));
+      await reconcileConnectedAccountBilling(user, existingCount + 1);
     }
     const session = providerConfigKey === "resend" ? await createResendConnectSession(user.email, resendOAuthCallbackUrl()) : await createNangoConnectSession(user.email, providerConfigKey);
     return c.json({ ok: true, ...session });
@@ -27266,7 +28033,7 @@ app.post("/billing/concurrency/checkout", requireAllowedOrigin, sessionAuth, asy
     if (user.concurrency_stripe_sub_id) return c.json({ error: "Already subscribed \u2014 cancel existing slot first to change." }, 409);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -27312,10 +28079,10 @@ app.post("/billing/subscribe", requireAllowedOrigin, sessionAuth, async (c) => {
     const user = c.get("sessionUser");
     const raw = await c.req.json().catch(() => ({}));
     const tier = SUBSCRIPTION_TIER_BY_KEY[String(raw.tier ?? "")];
-    if (!tier) return c.json({ error: "Invalid tier. Choose starter, growth, or scale." }, 400);
+    if (!tier) return c.json({ error: "Invalid subscription tier." }, 400);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -27367,7 +28134,7 @@ app.post("/billing/portal", requireAllowedOrigin, sessionAuth, async (c) => {
     if (!user.stripe_customer_id) return c.json({ error: "No billing account yet \u2014 subscribe first." }, 409);
     const secret2 = requireStripeSecret();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     const session = await stripeClient.billingPortal.sessions.create({
       customer: user.stripe_customer_id,
       return_url: `${appOrigin()}/billing`
@@ -27397,7 +28164,7 @@ app.post("/billing/concurrency/terminal-checkout", auth2, async (c) => {
     }
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -27441,7 +28208,7 @@ app.post("/billing/subscribe/terminal-checkout", auth2, async (c) => {
     if (!tier) return c.json({ error: "Invalid tier. Choose starter, growth, or scale.", tiers: Object.keys(SUBSCRIPTION_TIER_BY_KEY) }, 400);
     const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
     if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
-    const stripeClient = new Stripe3(secret2, { apiVersion: STRIPE_API_VERSION2 });
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
     let customerId = user.stripe_customer_id;
     if (!customerId) {
       const customer = await stripeClient.customers.create({ email: user.email });
@@ -27502,7 +28269,7 @@ app.post("/billing/concurrency/cancel", requireAllowedOrigin, sessionAuth, async
   if (!user.concurrency_stripe_sub_id) return c.json({ error: "No active concurrency subscription." }, 404);
   const stripeSecret = process.env.STRIPE_SECRET_KEY?.trim();
   if (!stripeSecret) return c.json({ error: "Stripe is not configured." }, 503);
-  const stripeClient = new Stripe3(stripeSecret, { apiVersion: STRIPE_API_VERSION2 });
+  const stripeClient = new Stripe2(stripeSecret, { apiVersion: STRIPE_API_VERSION });
   await stripeClient.subscriptions.cancel(user.concurrency_stripe_sub_id);
   const nextSlots = Math.max(0, user.extra_concurrency_slots - 1);
   await setExtraConcurrencySlots(user.id, nextSlots);
@@ -27564,7 +28331,7 @@ app.get("/cron/tick", async (c) => {
   if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
     return c.json({ error: "Unauthorized" }, 401);
   }
-  const { drainQueue } = await import("./worker-JU5FX3NE.js");
+  const { drainQueue } = await import("./worker-BJ64GCDE.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
   const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
   const [results, sweepResult, reapResult, expiredResult, blobCleanup, connectedDataArtifactCleanup] = await Promise.all([
@@ -27592,15 +28359,15 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     return c.json({ error: "Unauthorized" }, 401);
   }
   const jobId = c.req.param("id");
-  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-O36SIFI2.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-NFFVMUMT.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-ZDTO7ODZ.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-YNXTFCC3.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
   const stored = await assembleExtractArtifacts(job, {});
   await completeExtractJob2(jobId, stored);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-O36SIFI2.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-ZDTO7ODZ.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -27767,4 +28534,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-LNCSY6ME.js.map
+//# sourceMappingURL=server-SHOYO52X.js.map