mcp-scraper 0.4.1 → 0.4.3

package/dist/{server-U7V6DUSY.js → server-LBEYRKM2.js}

@@ -16,7 +16,7 @@ import {
   recordVendorUsage,
   resolveKernelProxyId,
   runWithCostContext
-} from "./chunk-HBC4C75S.js";
+} from "./chunk-NJK5BTUK.js";
 import {
   HttpMcpToolExecutor,
   MemoryMcpToolExecutor,
@@ -31,7 +31,7 @@ import {
   registerSerpIntelligenceCaptureTools,
   sanitizeAttempts,
   sanitizeHarvestResult
-} from "./chunk-QUOZ3LZG.js";
+} from "./chunk-BAMVP57P.js";
 import {
   auditImages,
   getBlobStore
@@ -53,7 +53,7 @@ import {
   workflowOutputBaseDir,
   workflowStepCount,
   workflowSupportsSteps
-} from "./chunk-NNEIXK5L.js";
+} from "./chunk-FUWZWKGO.js";
 import "./chunk-K443GQY5.js";
 import {
   DEFAULT_MAPS_PROXY_MODE,
@@ -64,8 +64,8 @@ import {
   RawMapsHoursRowSchema,
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
-} from "./chunk-BP27CZ5Q.js";
-import "./chunk-2ULBZRQQ.js";
+} from "./chunk-XGIPATLV.js";
+import "./chunk-SRMGSCC3.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -76,7 +76,7 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-JOEZJL4I.js";
+} from "./chunk-NVUBFCJK.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -95,7 +95,7 @@ import {
   browserActiveCostMc,
   concurrencySlotBillingInfo,
   insufficientBalanceResponse
-} from "./chunk-6TDUY7CA.js";
+} from "./chunk-4MFYMUIF.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -5274,7 +5274,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono20 } from "hono";
+import { Hono as Hono21 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -11846,6 +11846,8 @@ function verifySession(token) {
 }
 
 // src/api/memory.ts
+import { provisionDefaultsTool } from "mcpscraper-memory-tools/tools/vaults/provision-defaults";
+import { setScheduleEntitlementTool } from "mcpscraper-memory-tools/tools/schedule/set-schedule-entitlement";
 var MEMORY_BASE_URL = () => (process.env.MCP_MEMORY_BASE_URL ?? "https://memory.mcpscraper.dev").replace(/\/$/, "");
 var ADMIN_KEY = () => process.env.MCP_MEMORY_ADMIN_KEY?.trim() ?? "";
 function parseMemoryRpcBody(text) {
@@ -11933,6 +11935,24 @@ async function provisionMemoryForUser(user) {
   } catch {
   }
 }
+function memoryPlanForUser(user) {
+  switch (user.subscription_tier) {
+    case "starter":
+      return "pro";
+    case "growth":
+      return "team";
+    case "scale":
+      return "enterprise";
+    default:
+      return "free";
+  }
+}
+var MEMORY_PLAN_RANK = { free: 0, pro: 1, team: 2, enterprise: 3 };
+function resolveEffectiveMemoryPlan(user) {
+  const tierPlan = memoryPlanForUser(user);
+  const memoryProPlan = user.memory_plan === "pro" || user.memory_plan === "team" ? user.memory_plan : "free";
+  return MEMORY_PLAN_RANK[tierPlan] >= MEMORY_PLAN_RANK[memoryProPlan] ? tierPlan : memoryProPlan;
+}
 async function getOrCreateUserMemoryKey(user) {
   const creds = await getUserMemoryCreds(user.id);
   if (creds.memory_key) {
@@ -11943,10 +11963,9 @@ async function getOrCreateUserMemoryKey(user) {
   if (!admin) return { key: null, error: "memory not configured (MCP_MEMORY_ADMIN_KEY missing)" };
   const identity = memoryIdentity(user);
   const plan = isMemoryOperator(user.email) ? "unlimited" : (await getMemoryPlan(user.id)).plan;
-  const provisioned = await memoryCall(
-    "provisionDefaultsTool",
-    { granteeIdentity: identity, issueKey: true, plan },
-    admin
+  const provisioned = await provisionDefaultsTool.execute(
+    { apiKey: admin, granteeIdentity: identity, issueKey: true, plan },
+    {}
   );
   if (!provisioned.ok || !provisioned.secret) {
     return { key: null, error: provisioned.error ?? "failed to provision default vaults" };
@@ -11973,12 +11992,13 @@ async function syncScheduleEntitlement(user, enabled, quotaPerPeriod) {
   const admin = ADMIN_KEY();
   if (!admin) return { ok: false, error: "memory not configured (MCP_MEMORY_ADMIN_KEY missing)" };
   const identity = resolveMemoryIdentity(user);
-  const res = await memoryCall("setScheduleEntitlementTool", {
+  const res = await setScheduleEntitlementTool.execute({
+    apiKey: admin,
     granteeIdentity: identity,
     enabled,
     quotaPerPeriod,
     mcpScraperApiKey: user.api_key
-  }, admin);
+  }, {});
   return { ok: res.ok, error: res.error };
 }
 
@@ -12138,6 +12158,33 @@ var MapsNavigator = class {
     await this.page.waitForSelector('[role="main"] h2', { timeout: 5e3 }).catch(() => {
     });
   }
+  async navigateToSerpBusinessPanel(businessName, location2) {
+    const query = `${businessName} ${location2}`;
+    const searchUrl = `https://www.google.com/search?q=${encodeURIComponent(query)}&udm=1`;
+    await this.page.goto(searchUrl, { waitUntil: "domcontentloaded", timeout: 45e3 }).catch(() => {
+    });
+    await this.page.waitForTimeout(2e3);
+    const clicked = await this.page.evaluate((name) => {
+      const trimmedName = name.trim();
+      const words = trimmedName.split(/\s+/);
+      const prefix = words.slice(0, Math.min(2, words.length)).join(" ");
+      const headings = Array.from(document.querySelectorAll('h3, div[role="heading"]'));
+      const heading = headings.find((el2) => el2.innerText?.trim() === trimmedName) ?? headings.find((el2) => el2.innerText?.trim().startsWith(prefix));
+      const clickable = heading?.closest('a, div[role="link"], div[jsaction]');
+      if (clickable) {
+        clickable.click();
+        return true;
+      }
+      if (heading) {
+        heading.click();
+        return true;
+      }
+      return false;
+    }, businessName);
+    if (!clicked) return false;
+    await this.page.waitForTimeout(2e3);
+    return true;
+  }
   buildReviewsUrl(placeUrl) {
     const fid = placeUrl.match(/!1s(0x[0-9a-f]+:0x[0-9a-f]+)/i);
     const pin = placeUrl.match(/!3d(-?\d+\.\d+)!4d(-?\d+\.\d+)/);
@@ -12307,6 +12354,25 @@ var MapsExtractor = class {
       }
       await navigator.navigateToAboutTab();
       const aboutAttributes = await this.extractAbout(page);
+      let services = [];
+      let areasServed = [];
+      let servicesStatus = "not_requested";
+      if (options.includeServices) {
+        try {
+          const opened = await navigator.navigateToSerpBusinessPanel(options.businessName, options.location);
+          if (opened) {
+            const result = await this.extractServicesAndAreasServed(page);
+            services = result.services;
+            areasServed = result.areasServed;
+            servicesStatus = services.length > 0 || areasServed.length > 0 ? "collected" : "none_exist";
+          } else {
+            servicesStatus = "unavailable";
+          }
+        } catch (err) {
+          console.warn("[MapsExtractor] services/areas-served extraction failed:", err instanceof Error ? err.message : String(err));
+          servicesStatus = "unavailable";
+        }
+      }
       const reviewCountFinal = overview.reviewCount ?? (reviewStats.reviewHistogram.length > 0 ? reviewStats.reviewHistogram.reduce((s, r) => s + parseInt(r.count, 10), 0).toString() : null);
       return {
         businessName: options.businessName,
@@ -12322,6 +12388,9 @@ var MapsExtractor = class {
         aboutAttributes,
         reviews,
         reviewsStatus,
+        services,
+        areasServed,
+        servicesStatus,
         durationMs: Date.now() - startMs
       };
     } finally {
@@ -12510,6 +12579,81 @@ var MapsExtractor = class {
     }
     return result.data;
   }
+  async extractServicesAndAreasServed(page) {
+    await page.waitForTimeout(1500);
+    let services = [];
+    if (await this.clickRowStartingWithRetry(page, "Services:")) {
+      await page.waitForSelector('[role="dialog"]', { timeout: 5e3 }).catch(() => {
+      });
+      await page.waitForTimeout(800);
+      services = await this.extractOpenDialogItems(page, "Services");
+      await this.closeOpenDialog(page, "Services");
+      await page.waitForTimeout(500);
+    }
+    let areasServed = [];
+    if (await this.clickRowStartingWithRetry(page, "Serves ")) {
+      await page.waitForSelector('[role="dialog"]', { timeout: 5e3 }).catch(() => {
+      });
+      await page.waitForTimeout(800);
+      areasServed = await this.extractOpenDialogItems(page, "Areas Served");
+      await this.closeOpenDialog(page, "Areas Served");
+    }
+    return { services, areasServed };
+  }
+  async clickRowStartingWithRetry(page, prefix) {
+    if (await this.clickRowStartingWith(page, prefix)) return true;
+    await page.waitForTimeout(2e3);
+    return this.clickRowStartingWith(page, prefix);
+  }
+  async clickRowStartingWith(page, prefix) {
+    return page.evaluate((p) => {
+      const el2 = Array.from(document.querySelectorAll('button, a, div[role="button"]')).find(
+        (e) => (e.innerText ?? "").trim().startsWith(p)
+      );
+      if (!el2) return false;
+      el2.click();
+      return true;
+    }, prefix);
+  }
+  async extractOpenDialogItems(page, expectedHeading) {
+    return page.evaluate((expected) => {
+      const dialogs = Array.from(document.querySelectorAll('[role="dialog"]'));
+      const withHeading = dialogs.find((d) => {
+        const h = d.querySelector('h1, h2, [role="heading"]');
+        const headingText = h?.innerText?.trim() ?? "";
+        return headingText.startsWith(expected);
+      });
+      if (!withHeading) return [];
+      const headingEl = withHeading.querySelector('h1, h2, [role="heading"]');
+      const headingLines = new Set(
+        (headingEl?.innerText ?? "").split("\n").map((s) => s.trim()).filter(Boolean)
+      );
+      const seen = /* @__PURE__ */ new Set();
+      const items = [];
+      withHeading.querySelectorAll("*").forEach((el2) => {
+        if (el2.children.length > 0) return;
+        const text = el2.innerText?.trim() ?? el2.textContent?.trim() ?? "";
+        if (!text || headingLines.has(text)) return;
+        if (/^(back|close|done|thanks)$/i.test(text)) return;
+        if (/^serves\s.*following/i.test(text)) return;
+        if (seen.has(text)) return;
+        seen.add(text);
+        items.push(text);
+      });
+      return items;
+    }, expectedHeading);
+  }
+  async closeOpenDialog(page, expectedHeading) {
+    await page.evaluate((expected) => {
+      const dialog = Array.from(document.querySelectorAll('[role="dialog"]')).find((d) => {
+        const h = d.querySelector('h1, h2, [role="heading"]');
+        const headingText = h?.innerText?.trim() ?? "";
+        return headingText.startsWith(expected);
+      });
+      const closeBtn = dialog?.querySelector('[aria-label*="Close" i], button[aria-label*="close" i]');
+      closeBtn?.click();
+    }, expectedHeading);
+  }
 };
 
 // src/extractor/MapsSearchExtractor.ts
@@ -13016,13 +13160,163 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
   }
 });
 
-// src/api/directory-routes.ts
+// src/api/trustpilot-routes.ts
 import { Hono as Hono11 } from "hono";
+import { z as z19 } from "zod";
+var TrustpilotReviewsBodySchema = z19.object({
+  domain: z19.string().trim().min(1, "domain is required"),
+  maxPages: z19.number().int().min(1).max(50).default(5)
+});
+function invalidRequest6(message) {
+  return { error_code: "invalid_request", message };
+}
+function normalizeDomain(input) {
+  return input.trim().replace(/^https?:\/\//i, "").replace(/\/.*$/, "");
+}
+function reviewPageUrl(domain, page) {
+  const base = `https://www.trustpilot.com/review/${encodeURIComponent(domain)}`;
+  return page <= 1 ? base : `${base}?page=${page}`;
+}
+async function extractReviewCards(page) {
+  return page.evaluate(() => {
+    const cards = Array.from(document.querySelectorAll('article[data-service-review-card-paper="true"]')).filter((a) => a.querySelector('[data-testid="service-review-card-v2"]'));
+    return cards.map((card) => {
+      const profileLink = card.querySelector('a[data-consumer-profile-link="true"]');
+      const profileHref = profileLink?.getAttribute("href") ?? "";
+      const profileId = profileHref.startsWith("/users/") ? profileHref.slice("/users/".length) : null;
+      const name = card.querySelector('[data-consumer-name-typography="true"]')?.textContent?.trim() ?? null;
+      const timeEl = card.querySelector("time[datetime]");
+      const date = timeEl?.getAttribute("datetime") ?? null;
+      const ratingEl = card.querySelector("[data-service-review-rating]");
+      const ratingRaw = ratingEl?.getAttribute("data-service-review-rating");
+      const rating = ratingRaw ? parseInt(ratingRaw, 10) : null;
+      const titleLink = card.querySelector('a[data-review-title-typography="true"]');
+      const titleHref = titleLink?.getAttribute("href") ?? "";
+      const reviewId = titleHref.startsWith("/reviews/") ? titleHref.slice("/reviews/".length) : null;
+      const title = card.querySelector('[data-service-review-title-typography="true"]')?.textContent?.trim() ?? null;
+      const bodyEl = card.querySelector('[data-service-review-text-typography="true"]');
+      const rawBody = bodyEl?.textContent?.trim() ?? "";
+      const seeMoreEl = card.querySelector('[class*="seeMore"]');
+      const truncated = !!seeMoreEl;
+      const body = truncated ? rawBody.replace(/see more\s*$/i, "").trim() : rawBody;
+      const labelEl = card.querySelector('[class*="reviewLabel"]');
+      const labelText = labelEl?.textContent?.trim() ?? null;
+      const origin = labelText && /invit/i.test(labelText) ? "invited" : labelText ? labelText.toLowerCase() : "organic";
+      const companyReplied = !!card.querySelector('[class*="companyReply"]');
+      return {
+        source: "trustpilot",
+        sourceReviewId: reviewId,
+        reviewUrl: reviewId ? `https://www.trustpilot.com/reviews/${reviewId}` : null,
+        reviewer: {
+          name,
+          profileId,
+          title: null,
+          companySegment: null
+        },
+        rating,
+        ratingScale: 5,
+        title,
+        date,
+        body: [{ question: null, answer: body }],
+        truncated,
+        flags: {
+          origin,
+          incentivized: null,
+          validated: null,
+          currentUser: null,
+          companyReplied
+        }
+      };
+    });
+  });
+}
+var trustpilotApp = new Hono11();
+trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = TrustpilotReviewsBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest6(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const domain = normalizeDomain(body.domain);
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "trustpilot_reviews", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { domain, maxPages: body.maxPages }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
+  let reviewDebitMc = 0;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.trustpilot_reviews, LedgerOperation.TRUSTPILOT_REVIEWS, domain);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.trustpilot_reviews), 402);
+    debited = true;
+    const startMs = Date.now();
+    const driver = new BrowserDriver();
+    const allReviews = [];
+    let pagesFetched = 0;
+    try {
+      await driver.launch({
+        headless: true,
+        kernelApiKey: browserServiceApiKey(),
+        viewport: { width: 1280, height: 900 },
+        locale: "en-US"
+      });
+      const page = driver.getPage();
+      for (let pageNum = 1; pageNum <= body.maxPages; pageNum++) {
+        const url = reviewPageUrl(domain, pageNum);
+        await page.goto(url, { waitUntil: "domcontentloaded", timeout: 45e3 });
+        await page.waitForTimeout(2e3);
+        const cards = await extractReviewCards(page);
+        pagesFetched = pageNum;
+        if (cards.length === 0) break;
+        allReviews.push(...cards);
+      }
+    } finally {
+      await driver.close();
+    }
+    if (pagesFetched === 0 || allReviews.length === 0) {
+      await creditMc(user.id, MC_COSTS.trustpilot_reviews, LedgerOperation.TRUSTPILOT_REVIEWS_REFUND, "no reviews found");
+      await logRequestEvent({ userId: user.id, source: "trustpilot_reviews", status: "failed", query: domain, error: "no reviews found" });
+      return c.json({ error: "No reviews found for this domain (refunded)", domain }, 404);
+    }
+    reviewDebitMc = allReviews.length * MC_COSTS.trustpilot_review;
+    if (reviewDebitMc > 0) {
+      const reviewDebit = await debitMc(user.id, reviewDebitMc, LedgerOperation.TRUSTPILOT_REVIEW, domain);
+      if (!reviewDebit.ok) {
+        allReviews.length = Math.floor((reviewDebit.balance_mc ?? 0) / MC_COSTS.trustpilot_review);
+        reviewDebitMc = allReviews.length * MC_COSTS.trustpilot_review;
+        if (reviewDebitMc > 0) await debitMc(user.id, reviewDebitMc, LedgerOperation.TRUSTPILOT_REVIEW, domain);
+      }
+    }
+    const result = {
+      domain,
+      reviewUrl: reviewPageUrl(domain, 1),
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      requestedMaxPages: body.maxPages,
+      pagesFetched,
+      reviewCount: allReviews.length,
+      reviews: allReviews,
+      durationMs: Date.now() - startMs
+    };
+    await logRequestEvent({ userId: user.id, source: "trustpilot_reviews", status: "done", query: domain, resultCount: allReviews.length, result });
+    return c.json(result);
+  } catch (err) {
+    if (debited) await creditMc(user.id, MC_COSTS.trustpilot_reviews, LedgerOperation.TRUSTPILOT_REVIEWS_REFUND, "failed call");
+    if (reviewDebitMc > 0) await creditMc(user.id, reviewDebitMc, LedgerOperation.TRUSTPILOT_REVIEW_REFUND, "failed call");
+    const msg = err instanceof Error ? err.message : String(err);
+    await logRequestEvent({ userId: user.id, source: "trustpilot_reviews", status: "failed", query: domain, error: msg });
+    return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+
+// src/api/directory-routes.ts
+import { Hono as Hono12 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join5 } from "path";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -13183,24 +13477,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z19.object({
-  query: z19.string().min(1),
-  state: z19.string().min(2).default("TN"),
-  minPopulation: z19.number().int().min(0).default(1e5),
-  populationYear: z19.union(POPULATION_YEARS.map((year) => z19.literal(year))).default(2025),
-  maxCities: z19.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z19.number().int().min(1).max(50).default(50),
-  concurrency: z19.number().int().min(1).max(5).default(5),
-  includeZipGroups: z19.boolean().default(true),
-  usZipsCsvPath: z19.string().optional(),
-  saveCsv: z19.boolean().default(true),
-  gl: z19.string().length(2).default("us"),
-  hl: z19.string().length(2).default("en"),
-  proxyMode: z19.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z19.string().regex(/^\d{5}$/).optional(),
-  debug: z19.boolean().default(false),
-  headless: z19.boolean().default(true),
-  kernelApiKey: z19.string().optional()
+var DirectoryWorkflowOptionsSchema = z20.object({
+  query: z20.string().min(1),
+  state: z20.string().min(2).default("TN"),
+  minPopulation: z20.number().int().min(0).default(1e5),
+  populationYear: z20.union(POPULATION_YEARS.map((year) => z20.literal(year))).default(2025),
+  maxCities: z20.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z20.number().int().min(1).max(50).default(50),
+  concurrency: z20.number().int().min(1).max(5).default(5),
+  includeZipGroups: z20.boolean().default(true),
+  usZipsCsvPath: z20.string().optional(),
+  saveCsv: z20.boolean().default(true),
+  gl: z20.string().length(2).default("us"),
+  hl: z20.string().length(2).default("en"),
+  proxyMode: z20.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z20.string().regex(/^\d{5}$/).optional(),
+  debug: z20.boolean().default(false),
+  headless: z20.boolean().default(true),
+  kernelApiKey: z20.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -13421,7 +13715,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono11();
+var directoryApp = new Hono12();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -13494,35 +13788,35 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 // src/api/workflow-routes.ts
 import { createHmac as createHmac2 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono12 } from "hono";
-import { z as z20 } from "zod";
-var workflowApp = new Hono12();
-var WorkflowInputSchema = z20.record(z20.unknown()).default({});
-var WorkflowIdSchema = z20.string().min(1);
-var CadenceSchema = z20.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z20.enum(["active", "paused"]);
-var RunBodySchema = z20.object({
+import { Hono as Hono13 } from "hono";
+import { z as z21 } from "zod";
+var workflowApp = new Hono13();
+var WorkflowInputSchema = z21.record(z21.unknown()).default({});
+var WorkflowIdSchema = z21.string().min(1);
+var CadenceSchema = z21.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z21.enum(["active", "paused"]);
+var RunBodySchema = z21.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z20.string().url().optional()
+  webhookUrl: z21.string().url().optional()
 });
-var ScheduleCreateSchema = z20.object({
+var ScheduleCreateSchema = z21.object({
   workflowId: WorkflowIdSchema,
-  name: z20.string().min(1).max(120).optional(),
+  name: z21.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z20.string().min(1).max(64).default("UTC"),
-  webhookUrl: z20.string().url().optional(),
-  nextRunAt: z20.string().datetime().optional()
+  timezone: z21.string().min(1).max(64).default("UTC"),
+  webhookUrl: z21.string().url().optional(),
+  nextRunAt: z21.string().datetime().optional()
 });
-var SchedulePatchSchema = z20.object({
-  name: z20.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z21.object({
+  name: z21.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z20.string().min(1).max(64).optional(),
-  webhookUrl: z20.string().url().nullable().optional(),
-  nextRunAt: z20.string().datetime().nullable().optional()
+  timezone: z21.string().min(1).max(64).optional(),
+  webhookUrl: z21.string().url().nullable().optional(),
+  nextRunAt: z21.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -14026,7 +14320,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash as createHash2 } from "crypto";
@@ -14338,7 +14632,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -14400,171 +14694,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z21.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z21.object({
-  query: z21.string().trim().min(1, "query is required"),
-  location: z21.string().trim().min(1).optional(),
-  gl: z21.string().trim().length(2).default("us"),
-  hl: z21.string().trim().length(2).default("en"),
-  device: z21.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z21.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z21.string().regex(/^\d{5}$/).optional(),
-  pages: z21.number().int().min(1).max(2).default(1),
-  debug: z21.boolean().default(false),
-  includePageSnapshots: z21.boolean().default(false),
-  pageSnapshotLimit: z21.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z22.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z22.object({
+  query: z22.string().trim().min(1, "query is required"),
+  location: z22.string().trim().min(1).optional(),
+  gl: z22.string().trim().length(2).default("us"),
+  hl: z22.string().trim().length(2).default("en"),
+  device: z22.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z22.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z22.string().regex(/^\d{5}$/).optional(),
+  pages: z22.number().int().min(1).max(2).default(1),
+  debug: z22.boolean().default(false),
+  includePageSnapshots: z22.boolean().default(false),
+  pageSnapshotLimit: z22.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z21.object({
+var SerpIntelligencePageSnapshotRequestSchema = z22.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z21.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z21.number().int().min(1).optional()
+  sourceKind: z22.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z22.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z21.object({
-  urls: z21.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z21.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z21.number().int().min(1).max(5).default(2),
-  timeoutMs: z21.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z21.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z22.object({
+  urls: z22.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z22.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z22.number().int().min(1).max(5).default(2),
+  timeoutMs: z22.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z22.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z21.object({
-  text: z21.string(),
-  href: z21.string()
+var SerpIntelligenceAICitationSchema = z22.object({
+  text: z22.string(),
+  href: z22.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z21.object({
-  position: z21.number().int().min(1),
-  title: z21.string(),
-  url: z21.string(),
-  domain: z21.string(),
-  cite: z21.string().nullable(),
-  snippet: z21.string().nullable(),
-  isRedditStyle: z21.boolean(),
-  inlineRating: z21.object({
-    value: z21.string(),
-    count: z21.string()
+var SerpIntelligenceOrganicResultSchema = z22.object({
+  position: z22.number().int().min(1),
+  title: z22.string(),
+  url: z22.string(),
+  domain: z22.string(),
+  cite: z22.string().nullable(),
+  snippet: z22.string().nullable(),
+  isRedditStyle: z22.boolean(),
+  inlineRating: z22.object({
+    value: z22.string(),
+    count: z22.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z21.object({
-  status: z21.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z21.object({
-    city: z21.string(),
-    regionCode: z21.string().nullable(),
-    canonicalLocation: z21.string()
+var SerpIntelligenceLocationEvidenceSchema = z22.object({
+  status: z22.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z22.object({
+    city: z22.string(),
+    regionCode: z22.string().nullable(),
+    canonicalLocation: z22.string()
   }).strict().nullable(),
-  candidates: z21.array(z21.object({
-    city: z21.string(),
-    regionCode: z21.string(),
-    count: z21.number().int().min(0),
-    examples: z21.array(z21.string())
+  candidates: z22.array(z22.object({
+    city: z22.string(),
+    regionCode: z22.string(),
+    count: z22.number().int().min(0),
+    examples: z22.array(z22.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z21.object({
-  seed: z21.string(),
-  location: z21.string().nullable(),
-  extractedAt: z21.string(),
-  totalQuestions: z21.number().int().min(0),
-  surface: z21.enum(["web", "aim", "unknown"]),
-  aiOverview: z21.object({
-    detected: z21.boolean(),
-    text: z21.string().nullable(),
-    citations: z21.array(SerpIntelligenceAICitationSchema),
-    expanded: z21.boolean().optional(),
-    fullyExpanded: z21.boolean().optional(),
-    sections: z21.array(z21.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z22.object({
+  seed: z22.string(),
+  location: z22.string().nullable(),
+  extractedAt: z22.string(),
+  totalQuestions: z22.number().int().min(0),
+  surface: z22.enum(["web", "aim", "unknown"]),
+  aiOverview: z22.object({
+    detected: z22.boolean(),
+    text: z22.string().nullable(),
+    citations: z22.array(SerpIntelligenceAICitationSchema),
+    expanded: z22.boolean().optional(),
+    fullyExpanded: z22.boolean().optional(),
+    sections: z22.array(z22.string()).optional()
   }).strict(),
-  aiMode: z21.object({
-    detected: z21.boolean(),
-    text: z21.string().nullable(),
-    citations: z21.array(SerpIntelligenceAICitationSchema)
+  aiMode: z22.object({
+    detected: z22.boolean(),
+    text: z22.string().nullable(),
+    citations: z22.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z21.array(z21.unknown()),
-  flat: z21.array(z21.unknown()),
-  videos: z21.array(z21.unknown()),
-  forums: z21.array(z21.unknown()),
-  organicResults: z21.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z21.array(z21.unknown()),
-  entityIds: z21.object({
-    entities: z21.array(z21.object({
-      name: z21.string(),
-      kgId: z21.string().nullable(),
-      cid: z21.string().nullable(),
-      gcid: z21.string().nullable()
+  tree: z22.array(z22.unknown()),
+  flat: z22.array(z22.unknown()),
+  videos: z22.array(z22.unknown()),
+  forums: z22.array(z22.unknown()),
+  organicResults: z22.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z22.array(z22.unknown()),
+  entityIds: z22.object({
+    entities: z22.array(z22.object({
+      name: z22.string(),
+      kgId: z22.string().nullable(),
+      cid: z22.string().nullable(),
+      gcid: z22.string().nullable()
     }).strict()),
-    kgIds: z21.array(z21.string()),
-    cids: z21.array(z21.string()),
-    gcids: z21.array(z21.string())
+    kgIds: z22.array(z22.string()),
+    cids: z22.array(z22.string()),
+    gcids: z22.array(z22.string())
   }).strict(),
-  stats: z21.object({
-    seed: z21.string(),
-    totalQuestions: z21.number().int().min(0),
-    maxDepthReached: z21.number().int().min(0),
-    durationMs: z21.number().min(0),
-    errorCount: z21.number().int().min(0)
+  stats: z22.object({
+    seed: z22.string(),
+    totalQuestions: z22.number().int().min(0),
+    maxDepthReached: z22.number().int().min(0),
+    durationMs: z22.number().min(0),
+    errorCount: z22.number().int().min(0)
   }).strict(),
-  diagnostics: z21.object({
-    completionStatus: z21.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z21.null(),
-    warnings: z21.array(z21.unknown()).optional(),
-    debug: z21.object({
+  diagnostics: z22.object({
+    completionStatus: z22.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z22.null(),
+    warnings: z22.array(z22.unknown()).optional(),
+    debug: z22.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z21.array(z21.unknown())
+  whatPeopleSaying: z22.array(z22.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z21.object({
-  attemptNumber: z21.number().int().min(1),
-  outcome: z21.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z21.string().optional(),
-  completedAt: z21.string().optional(),
-  durationMs: z21.number().min(0).optional(),
-  problemCode: z21.string().optional(),
-  message: z21.string().optional(),
-  kernelSessionId: z21.string().nullable().optional(),
-  cleanupSucceeded: z21.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z22.object({
+  attemptNumber: z22.number().int().min(1),
+  outcome: z22.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z22.string().optional(),
+  completedAt: z22.string().optional(),
+  durationMs: z22.number().min(0).optional(),
+  problemCode: z22.string().optional(),
+  message: z22.string().optional(),
+  kernelSessionId: z22.string().nullable().optional(),
+  cleanupSucceeded: z22.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z21.object({
+var SerpPageSnapshotCaptureSchema = z22.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z21.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z21.number().int().min(1).nullable(),
-  status: z21.enum(SerpPageFetchStatusValues),
-  fetchedVia: z21.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z21.number().int().min(100).max(599).nullable(),
-  contentType: z21.string().nullable(),
-  title: z21.string().nullable(),
+  sourceKind: z22.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z22.number().int().min(1).nullable(),
+  status: z22.enum(SerpPageFetchStatusValues),
+  fetchedVia: z22.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z22.number().int().min(100).max(599).nullable(),
+  contentType: z22.string().nullable(),
+  title: z22.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z21.string().nullable(),
-  headings: z21.array(z21.object({
-    level: z21.number().int().min(1).max(6),
-    text: z21.string()
+  metaDescription: z22.string().nullable(),
+  headings: z22.array(z22.object({
+    level: z22.number().int().min(1).max(6),
+    text: z22.string()
   }).strict()).default([]),
-  artifact: z21.object({
-    htmlBlobUrl: z21.string().url().nullable(),
-    textBlobUrl: z21.string().url().nullable(),
-    markdownBlobUrl: z21.string().url().nullable(),
-    screenshotBlobUrl: z21.string().url().nullable(),
-    contentSha256: z21.string().nullable(),
-    capturedAt: z21.string().nullable()
+  artifact: z22.object({
+    htmlBlobUrl: z22.string().url().nullable(),
+    textBlobUrl: z22.string().url().nullable(),
+    markdownBlobUrl: z22.string().url().nullable(),
+    screenshotBlobUrl: z22.string().url().nullable(),
+    contentSha256: z22.string().nullable(),
+    capturedAt: z22.string().nullable()
   }).strict(),
-  error: z21.object({
-    code: z21.string(),
-    message: z21.string()
+  error: z22.object({
+    code: z22.string(),
+    message: z22.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z21.object({
+var SerpIntelligenceCaptureResponseSchema = z22.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z21.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z22.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z21.array(SerpPageSnapshotCaptureSchema),
-  billing: z21.object({
-    creditsUsed: z21.number().min(0).optional(),
-    requestId: z21.string().optional(),
-    jobId: z21.string().optional()
+  pageSnapshotArtifacts: z22.array(SerpPageSnapshotCaptureSchema),
+  billing: z22.object({
+    creditsUsed: z22.number().min(0).optional(),
+    requestId: z22.string().optional(),
+    jobId: z22.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z21.object({
-  pageSnapshotArtifacts: z21.array(SerpPageSnapshotCaptureSchema),
-  attempts: z21.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z22.object({
+  pageSnapshotArtifacts: z22.array(SerpPageSnapshotCaptureSchema),
+  attempts: z22.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -14736,7 +15030,7 @@ var SERP_INTELLIGENCE_RATE_LIMIT = 60;
 var SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
 var POST_CAPTURE_ROUTE_LABEL = "POST /capture";
 var POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
-var serpIntelligenceApp = new Hono13();
+var serpIntelligenceApp = new Hono14();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -14905,9 +15199,447 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono14 } from "hono";
+import { Hono as Hono15 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
+// src/mcp/memory-inprocess-executor.ts
+var CUTOVER = /* @__PURE__ */ new Map();
+function registerCutover(upstreamName, handler) {
+  CUTOVER.set(upstreamName, handler);
+}
+var HybridMemoryToolExecutor = class {
+  constructor(httpExecutor, user) {
+    this.httpExecutor = httpExecutor;
+    this.user = user;
+  }
+  httpExecutor;
+  user;
+  mkKeyPromise = null;
+  async resolveMkKey() {
+    if (!this.mkKeyPromise) {
+      this.mkKeyPromise = getOrCreateUserMemoryKey(this.user).then((r) => r.key);
+    }
+    return this.mkKeyPromise;
+  }
+  async callMemoryTool(upstreamName, args) {
+    const handler = CUTOVER.get(upstreamName);
+    if (!handler) return this.httpExecutor.callMemoryTool(upstreamName, args);
+    const mkKey = await this.resolveMkKey();
+    if (!mkKey) return { content: [{ type: "text", text: "memory unavailable" }], isError: true };
+    try {
+      return await handler(args, mkKey);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : `memory ${upstreamName} failed in-process`;
+      return { content: [{ type: "text", text: message }], isError: true };
+    }
+  }
+};
+
+// src/mcp/memory-cutover/reads.ts
+import { listApprovedSendersTool } from "mcpscraper-memory-tools/tools/access/list-approved-senders";
+import { noteInboxTool } from "mcpscraper-memory-tools/tools/access/note-inbox";
+import { getMessageNoteTool } from "mcpscraper-memory-tools/tools/channels/get-message-note";
+import { listChannelMembersTool } from "mcpscraper-memory-tools/tools/channels/list-channel-members";
+import { myMentionsTool } from "mcpscraper-memory-tools/tools/channels/my-mentions";
+import { factHistoryTool } from "mcpscraper-memory-tools/tools/facts/fact-history";
+import { exportTool } from "mcpscraper-memory-tools/tools/memory/export";
+import { getTool } from "mcpscraper-memory-tools/tools/memory/get";
+import { listTool } from "mcpscraper-memory-tools/tools/memory/list";
+import { searchTool } from "mcpscraper-memory-tools/tools/memory/search";
+import { suggestTool } from "mcpscraper-memory-tools/tools/memory/suggest";
+import { temporalRecallTool } from "mcpscraper-memory-tools/tools/recall/temporal-recall";
+import { listScheduledActionsTool } from "mcpscraper-memory-tools/tools/schedule/list-scheduled-actions";
+import { costUsageTool } from "mcpscraper-memory-tools/tools/storage/cost-usage";
+import { storageUsageTool } from "mcpscraper-memory-tools/tools/storage/storage-usage";
+import { describeTableTool } from "mcpscraper-memory-tools/tools/tables/table-describe";
+import { listTablesTool } from "mcpscraper-memory-tools/tools/tables/table-list";
+import { queryTableTool } from "mcpscraper-memory-tools/tools/tables/table-query";
+import { listSharedWithMeTool } from "mcpscraper-memory-tools/tools/vaults/list-shared-with-me";
+import { listVaultsTool } from "mcpscraper-memory-tools/tools/vaults/list-vaults";
+import { videoAnalyzeStatusTool } from "mcpscraper-memory-tools/tools/video/status";
+import { listWebhooksTool } from "mcpscraper-memory-tools/tools/webhooks/list-webhooks";
+var registered = false;
+function registerReadCutovers() {
+  if (registered) return;
+  registered = true;
+  registerCutover("listApprovedSendersTool", async (input, apiKey) => {
+    const result = await listApprovedSendersTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("noteInboxTool", async (input, apiKey) => {
+    const result = await noteInboxTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("getMessageNoteTool", async (input, apiKey) => {
+    const result = await getMessageNoteTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listChannelMembersTool", async (input, apiKey) => {
+    const result = await listChannelMembersTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("myMentionsTool", async (input, apiKey) => {
+    const result = await myMentionsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("factHistoryTool", async (input, apiKey) => {
+    const result = await factHistoryTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("exportTool", async (input, apiKey) => {
+    const result = await exportTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("getTool", async (input, apiKey) => {
+    const result = await getTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listTool", async (input, apiKey) => {
+    const result = await listTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("searchTool", async (input, apiKey) => {
+    const result = await searchTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("suggestTool", async (input, apiKey) => {
+    const result = await suggestTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("temporalRecallTool", async (input, apiKey) => {
+    const result = await temporalRecallTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listScheduledActionsTool", async (input, apiKey) => {
+    const result = await listScheduledActionsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("costUsageTool", async (input, apiKey) => {
+    const result = await costUsageTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("storageUsageTool", async (input, apiKey) => {
+    const result = await storageUsageTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("describeTableTool", async (input, apiKey) => {
+    const result = await describeTableTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listTablesTool", async (input, apiKey) => {
+    const result = await listTablesTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("queryTableTool", async (input, apiKey) => {
+    const result = await queryTableTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listSharedWithMeTool", async (input, apiKey) => {
+    const result = await listSharedWithMeTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listVaultsTool", async (input, apiKey) => {
+    const result = await listVaultsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("videoAnalyzeStatusTool", async (input, apiKey) => {
+    const result = await videoAnalyzeStatusTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listWebhooksTool", async (input, apiKey) => {
+    const result = await listWebhooksTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+}
+
+// src/mcp/memory-cutover/writes.ts
+import { acceptShareTool } from "mcpscraper-memory-tools/tools/access/accept-share";
+import { approveSenderTool } from "mcpscraper-memory-tools/tools/access/approve-sender";
+import { declineShareTool } from "mcpscraper-memory-tools/tools/access/decline-share";
+import { inboxSettingsTool } from "mcpscraper-memory-tools/tools/access/inbox-settings";
+import { removeApprovedSenderTool } from "mcpscraper-memory-tools/tools/access/remove-approved-sender";
+import { revokeShareTool } from "mcpscraper-memory-tools/tools/access/revoke-share";
+import { setAgentIdentityTool } from "mcpscraper-memory-tools/tools/access/set-agent-identity";
+import { shareNoteTool } from "mcpscraper-memory-tools/tools/access/share-note";
+import { shareVaultTool } from "mcpscraper-memory-tools/tools/access/share-vault";
+import { swapVaultTool } from "mcpscraper-memory-tools/tools/access/swap-vault";
+import { switchAccountTool } from "mcpscraper-memory-tools/tools/access/switch-account";
+import { unlinkShareTool } from "mcpscraper-memory-tools/tools/access/unlink-share";
+import { memoryQuestionsTool } from "mcpscraper-memory-tools/tools/capture/memory-questions";
+import { createChannelTool } from "mcpscraper-memory-tools/tools/channels/create-channel";
+import { listChannelMessagesTool } from "mcpscraper-memory-tools/tools/channels/list-channel-messages";
+import { pollChannelTool } from "mcpscraper-memory-tools/tools/channels/poll-channel";
+import { postMessageTool } from "mcpscraper-memory-tools/tools/channels/post-message";
+import { reactMessageTool } from "mcpscraper-memory-tools/tools/channels/react-message";
+import { removeChannelMemberTool } from "mcpscraper-memory-tools/tools/channels/remove-channel-member";
+import { replyMessageTool } from "mcpscraper-memory-tools/tools/channels/reply-message";
+import { recordFactTool } from "mcpscraper-memory-tools/tools/facts/record-fact";
+import { libraryIngestTool } from "mcpscraper-memory-tools/tools/library/library-ingest";
+import { deleteNoteTool } from "mcpscraper-memory-tools/tools/memory/delete-note";
+import { putTool } from "mcpscraper-memory-tools/tools/memory/put";
+import { uploadTool } from "mcpscraper-memory-tools/tools/memory/upload";
+import { deleteScheduledActionTool } from "mcpscraper-memory-tools/tools/schedule/delete-scheduled-action";
+import { pauseScheduledActionTool } from "mcpscraper-memory-tools/tools/schedule/pause-scheduled-action";
+import { resumeScheduledActionTool } from "mcpscraper-memory-tools/tools/schedule/resume-scheduled-action";
+import { createTableTool } from "mcpscraper-memory-tools/tools/tables/table-create";
+import { deleteTableRowsTool } from "mcpscraper-memory-tools/tools/tables/table-delete-rows";
+import { dropTableTool } from "mcpscraper-memory-tools/tools/tables/table-drop";
+import { insertTableRowsTool } from "mcpscraper-memory-tools/tools/tables/table-insert-rows";
+import { addVaultTool } from "mcpscraper-memory-tools/tools/vaults/add-vault";
+import { deleteVaultTool } from "mcpscraper-memory-tools/tools/vaults/delete-vault";
+var registered2 = false;
+function registerWriteCutovers() {
+  if (registered2) return;
+  registered2 = true;
+  registerCutover("acceptShareTool", async (input, apiKey) => {
+    const result = await acceptShareTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("approveSenderTool", async (input, apiKey) => {
+    const result = await approveSenderTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("declineShareTool", async (input, apiKey) => {
+    const result = await declineShareTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("inboxSettingsTool", async (input, apiKey) => {
+    const result = await inboxSettingsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("removeApprovedSenderTool", async (input, apiKey) => {
+    const result = await removeApprovedSenderTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("revokeShareTool", async (input, apiKey) => {
+    const result = await revokeShareTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("setAgentIdentityTool", async (input, apiKey) => {
+    const result = await setAgentIdentityTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("shareNoteTool", async (input, apiKey) => {
+    const result = await shareNoteTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("shareVaultTool", async (input, apiKey) => {
+    const result = await shareVaultTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("swapVaultTool", async (input, apiKey) => {
+    const result = await swapVaultTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("switchAccountTool", async (input, apiKey) => {
+    const result = await switchAccountTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("unlinkShareTool", async (input, apiKey) => {
+    const result = await unlinkShareTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("memoryQuestionsTool", async (input, apiKey) => {
+    const result = await memoryQuestionsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("createChannelTool", async (input, apiKey) => {
+    const result = await createChannelTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listChannelMessagesTool", async (input, apiKey) => {
+    const result = await listChannelMessagesTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("pollChannelTool", async (input, apiKey) => {
+    const result = await pollChannelTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("postMessageTool", async (input, apiKey) => {
+    const result = await postMessageTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("reactMessageTool", async (input, apiKey) => {
+    const result = await reactMessageTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("removeChannelMemberTool", async (input, apiKey) => {
+    const result = await removeChannelMemberTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("replyMessageTool", async (input, apiKey) => {
+    const result = await replyMessageTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("recordFactTool", async (input, apiKey) => {
+    const result = await recordFactTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("libraryIngestTool", async (input, apiKey) => {
+    const result = await libraryIngestTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("deleteNoteTool", async (input, apiKey) => {
+    const result = await deleteNoteTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("putTool", async (input, apiKey) => {
+    const result = await putTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("uploadTool", async (input, apiKey) => {
+    const result = await uploadTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("deleteScheduledActionTool", async (input, apiKey) => {
+    const result = await deleteScheduledActionTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("pauseScheduledActionTool", async (input, apiKey) => {
+    const result = await pauseScheduledActionTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("resumeScheduledActionTool", async (input, apiKey) => {
+    const result = await resumeScheduledActionTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("createTableTool", async (input, apiKey) => {
+    const result = await createTableTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("deleteTableRowsTool", async (input, apiKey) => {
+    const result = await deleteTableRowsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("dropTableTool", async (input, apiKey) => {
+    const result = await dropTableTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("insertTableRowsTool", async (input, apiKey) => {
+    const result = await insertTableRowsTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("addVaultTool", async (input, apiKey) => {
+    const result = await addVaultTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("deleteVaultTool", async (input, apiKey) => {
+    const result = await deleteVaultTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+}
+
+// src/mcp/memory-cutover/billing.ts
+import { issueKeyTool } from "mcpscraper-memory-tools/tools/access/issue-key";
+import { listKeysTool } from "mcpscraper-memory-tools/tools/access/list-keys";
+import { revokeKeyTool } from "mcpscraper-memory-tools/tools/access/revoke-key";
+import { setScopeTool } from "mcpscraper-memory-tools/tools/access/set-scope";
+import { inviteAccountTool } from "mcpscraper-memory-tools/tools/access/invite-account";
+import { getChatLinkTool } from "mcpscraper-memory-tools/tools/access/get-chat-link";
+import { revokeChatLinkTool } from "mcpscraper-memory-tools/tools/access/revoke-chat-link";
+import { provisionDefaultsTool as provisionDefaultsTool2 } from "mcpscraper-memory-tools/tools/vaults/provision-defaults";
+import { createSecureVaultTool } from "mcpscraper-memory-tools/tools/vaults/create-secure-vault";
+import { createScheduledActionTool } from "mcpscraper-memory-tools/tools/schedule/create-scheduled-action";
+import { getScheduleStatusTool } from "mcpscraper-memory-tools/tools/schedule/get-schedule-status";
+import { getScheduleLinkTool } from "mcpscraper-memory-tools/tools/schedule/get-schedule-link";
+import { revokeScheduleLinkTool } from "mcpscraper-memory-tools/tools/schedule/revoke-schedule-link";
+import { setScheduleEntitlementTool as setScheduleEntitlementTool2 } from "mcpscraper-memory-tools/tools/schedule/set-schedule-entitlement";
+import { createWebhookTool } from "mcpscraper-memory-tools/tools/webhooks/create-webhook";
+import { revokeWebhookTool } from "mcpscraper-memory-tools/tools/webhooks/revoke-webhook";
+var registered3 = false;
+function registerBillingCutovers() {
+  if (registered3) return;
+  registered3 = true;
+  registerCutover("issueKeyTool", async (input, apiKey) => {
+    const result = await issueKeyTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("listKeysTool", async (input, apiKey) => {
+    const result = await listKeysTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("revokeKeyTool", async (input, apiKey) => {
+    const result = await revokeKeyTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("setScopeTool", async (input, apiKey) => {
+    const result = await setScopeTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("inviteAccountTool", async (input, apiKey) => {
+    const result = await inviteAccountTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("getChatLinkTool", async (input, apiKey) => {
+    const result = await getChatLinkTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("revokeChatLinkTool", async (input, apiKey) => {
+    const result = await revokeChatLinkTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("provisionDefaultsTool", async (input, apiKey) => {
+    const result = await provisionDefaultsTool2.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("createSecureVaultTool", async (input, apiKey) => {
+    const result = await createSecureVaultTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("createScheduledActionTool", async (input, apiKey) => {
+    const result = await createScheduledActionTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("getScheduleStatusTool", async (input, apiKey) => {
+    const result = await getScheduleStatusTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("getScheduleLinkTool", async (input, apiKey) => {
+    const result = await getScheduleLinkTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("revokeScheduleLinkTool", async (input, apiKey) => {
+    const result = await revokeScheduleLinkTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("setScheduleEntitlementTool", async (input, apiKey) => {
+    const result = await setScheduleEntitlementTool2.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("createWebhookTool", async (input, apiKey) => {
+    const result = await createWebhookTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+  registerCutover("revokeWebhookTool", async (input, apiKey) => {
+    const result = await revokeWebhookTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+}
+
+// src/mcp/memory-cutover/cross-service.ts
+import { proposeScheduledActionTool } from "mcpscraper-memory-tools/tools/schedule/propose-scheduled-action";
+var registered4 = false;
+function registerCrossServiceCutovers() {
+  if (registered4) return;
+  registered4 = true;
+  registerCutover("proposeScheduledActionTool", async (input, apiKey) => {
+    const result = await proposeScheduledActionTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+}
+
+// src/mcp/memory-cutover/video.ts
+import { videoAnalyzeStartTool } from "mcpscraper-memory-tools/tools/video/start";
+var registered5 = false;
+function registerVideoCutovers() {
+  if (registered5) return;
+  registered5 = true;
+  registerCutover("videoAnalyzeStartTool", async (input, apiKey) => {
+    const result = await videoAnalyzeStartTool.execute({ ...input, apiKey }, {});
+    return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }], structuredContent: result ?? {}, isError: false };
+  });
+}
+
 // src/mcp/mcp-oauth.ts
 import { createRemoteJWKSet, jwtVerify } from "jose";
 function oauthIssuer() {
@@ -14948,6 +15680,11 @@ async function verifyScraperOAuthJwt(token) {
 }
 
 // src/mcp/mcp-routes.ts
+registerReadCutovers();
+registerWriteCutovers();
+registerBillingCutovers();
+registerCrossServiceCutovers();
+registerVideoCutovers();
 configureReportSaving(false);
 function mcpAuthError(message = "authentication required") {
   const body = JSON.stringify({
@@ -14981,20 +15718,20 @@ async function requireMcpCallerKey(c) {
     if (!identity) return mcpAuthError("Bearer token has no subject");
     const user2 = await getUserByEmail(identity);
     if (!user2 || !user2.api_key || user2.key_active !== 1) return mcpAuthError("No active MCP Scraper account for this identity");
-    return user2.api_key;
+    return { key: user2.api_key, user: user2 };
   }
   const callerKey = xApiKey ?? bearerToken;
   if (!callerKey) return mcpAuthError();
   const user = await getUserByApiKey(callerKey);
   if (!user) return mcpAuthError();
-  return callerKey;
+  return { key: callerKey, user };
 }
-var mcpApp = new Hono14();
+var mcpApp = new Hono15();
 mcpApp.all("/", async (c) => {
   try {
     const keyOrError = await requireMcpCallerKey(c);
     if (keyOrError instanceof Response) return keyOrError;
-    const callerKey = keyOrError;
+    const { key: callerKey, user } = keyOrError;
     const baseUrl = process.env.MCP_SCRAPER_BASE_URL?.trim() ?? process.env.MCP_BASE_URL?.trim() ?? "https://mcpscraper.dev";
     const executor = new HttpMcpToolExecutor(baseUrl, callerKey);
     const transport = new WebStandardStreamableHTTPServerTransport({
@@ -15005,7 +15742,8 @@ mcpApp.all("/", async (c) => {
     const server = buildPaaExtractorMcpServer(executor, { savesReportsLocally: false, ownerId: hashOwnerId(callerKey) });
     registerSerpIntelligenceCaptureTools(server, executor);
     registerBrowserAgentMcpTools(server, { baseUrl, apiKey: callerKey, consoleBaseUrl, savesReportsLocally: false });
-    registerMemoryMcpTools(server, new MemoryMcpToolExecutor(baseUrl, callerKey));
+    const memoryExecutor = new HybridMemoryToolExecutor(new MemoryMcpToolExecutor(baseUrl, callerKey), user);
+    registerMemoryMcpTools(server, memoryExecutor);
     await server.connect(transport);
     return transport.handleRequest(c.req.raw);
   } catch {
@@ -15014,7 +15752,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono16 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -15093,23 +15831,34 @@ async function migrateBrowserAgent() {
     await db.execute(`ALTER TABLE browser_auth_connections ADD COLUMN updated_at TEXT`);
   } catch {
   }
+  try {
+    await db.execute(`ALTER TABLE browser_auth_connections ADD COLUMN status TEXT NOT NULL DEFAULT 'NEEDS_AUTH'`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE browser_auth_connections ADD COLUMN browser_agent_session_id TEXT`);
+  } catch {
+  }
   await db.execute(`CREATE INDEX IF NOT EXISTS browser_auth_connections_profile ON browser_auth_connections(profile)`);
   _ready = true;
 }
-async function saveAuthConnection(input) {
-  if (!input.connectionId) return;
+async function createAuthConnectionRow(input) {
+  const db = getDb();
+  const connectionId = `authc_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
+  await db.execute({
+    sql: `INSERT INTO browser_auth_connections (connection_id, domain, profile, account_email, note, status, browser_agent_session_id)
+          VALUES (?, ?, ?, ?, ?, 'NEEDS_AUTH', ?)`,
+    args: [connectionId, input.domain, input.profile, input.accountEmail, input.note, input.browserAgentSessionId]
+  });
+  const row = await getAuthConnectionRow(connectionId);
+  if (!row) throw new Error("auth connection insert failed");
+  return row;
+}
+async function markAuthConnectionAuthenticated(connectionId) {
   const db = getDb();
   await db.execute({
-    sql: `INSERT INTO browser_auth_connections (connection_id, hosted_url, domain, profile, account_email, note, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
-          ON CONFLICT(connection_id) DO UPDATE SET
-            hosted_url    = COALESCE(excluded.hosted_url, browser_auth_connections.hosted_url),
-            domain        = COALESCE(excluded.domain, browser_auth_connections.domain),
-            profile       = COALESCE(excluded.profile, browser_auth_connections.profile),
-            account_email = COALESCE(excluded.account_email, browser_auth_connections.account_email),
-            note          = COALESCE(excluded.note, browser_auth_connections.note),
-            updated_at    = datetime('now')`,
-    args: [input.connectionId, input.hostedUrl, input.domain, input.profile, input.accountEmail ?? null, input.note ?? null]
+    sql: `UPDATE browser_auth_connections SET status = 'AUTHENTICATED', updated_at = datetime('now') WHERE connection_id = ?`,
+    args: [connectionId]
   });
 }
 async function getAuthConnectionRow(connectionId) {
@@ -15956,79 +16705,10 @@ async function ensureProfile(k, name) {
     if (!isProfileConflict(err)) throw err;
   }
 }
-function profileConnectionMatches(connection, profileName, domain) {
-  if (!connection || typeof connection !== "object") return false;
-  const data = connection;
-  return data.profile_name === profileName && data.domain === domain;
-}
-async function findProfileConnection(k, profileName, domain) {
-  for await (const connection of k.auth.connections.list({ profile_name: profileName, domain })) {
-    if (profileConnectionMatches(connection, profileName, domain)) return connection;
-  }
-  return null;
-}
-async function listProfileConnections(profileName) {
-  if (!profileName) return [];
-  const k = client();
-  const out = [];
-  for await (const connection of k.auth.connections.list({ profile_name: profileName })) {
-    const data = connection;
-    if (data.profile_name && data.profile_name !== profileName) continue;
-    out.push(profileOnboardResult(connection));
-  }
-  return out;
-}
-async function findOrCreateProfileConnection(k, opts) {
-  try {
-    return await k.auth.connections.create({
-      domain: opts.domain,
-      profile_name: opts.profileName,
-      ...opts.loginUrl ? { login_url: opts.loginUrl } : {}
-    });
-  } catch (err) {
-    if (!isProfileConflict(err)) throw err;
-    const existing = await findProfileConnection(k, opts.profileName, opts.domain);
-    if (existing) return existing;
-    throw err;
-  }
-}
-function profileOnboardResult(connection, hostedUrl = null, liveViewUrl = null) {
-  return {
-    connectionId: String(connection.id),
-    profileName: String(connection.profile_name),
-    domain: String(connection.domain),
-    status: String(connection.status),
-    flowStatus: typeof connection.flow_status === "string" ? connection.flow_status : null,
-    flowStep: typeof connection.flow_step === "string" ? connection.flow_step : null,
-    flowExpiresAt: typeof connection.flow_expires_at === "string" ? connection.flow_expires_at : null,
-    hostedUrl: hostedUrl ?? (typeof connection.hosted_url === "string" ? connection.hosted_url : null),
-    liveViewUrl: liveViewUrl ?? (typeof connection.live_view_url === "string" ? connection.live_view_url : null),
-    browserSessionId: typeof connection.browser_session_id === "string" ? connection.browser_session_id : null,
-    postLoginUrl: typeof connection.post_login_url === "string" ? connection.post_login_url : null
-  };
-}
 function explicitProxyId(value) {
   const trimmed = value?.trim();
   return trimmed || void 0;
 }
-async function startProfileOnboarding(opts) {
-  const k = client();
-  const connection = await findOrCreateProfileConnection(k, opts);
-  const login = await k.auth.connections.login(connection.id);
-  const state = await k.auth.connections.retrieve(connection.id);
-  return profileOnboardResult(state, login.hosted_url ?? null, login.live_view_url ?? null);
-}
-async function getProfileOnboardingStatus(input) {
-  const k = client();
-  let connection = null;
-  if (input.connectionId) {
-    connection = await k.auth.connections.retrieve(input.connectionId);
-  } else if (input.profileName && input.domain) {
-    connection = await findProfileConnection(k, input.profileName, input.domain);
-  }
-  if (!connection) throw new Error("profile auth connection not found");
-  return profileOnboardResult(connection);
-}
 async function createSession(opts = {}) {
   const k = client();
   const resolvedProxyId = explicitProxyId(opts.proxyId);
@@ -16370,24 +17050,39 @@ async function charge(sessionId, userId, _startedAtMs) {
     if (res.ok) await setBilledMc(sessionId, owed);
   }
 }
+async function closeAndSettleSession(row) {
+  if (row.user_id != null) {
+    try {
+      await charge(row.id, row.user_id);
+    } catch {
+    }
+  }
+  try {
+    await closeSession(row.runtime_session_id);
+  } catch {
+  }
+  await markSessionClosed(row.id).catch(() => {
+  });
+  await releaseConcurrencyGate(row.concurrency_lock_id).catch(() => {
+  });
+}
+async function completeAuthConnection(connectionId) {
+  const connection = await getAuthConnectionRow(connectionId);
+  if (!connection) return { ok: false, error: "not found" };
+  if (connection.browser_agent_session_id) {
+    const sessionRow = await getSessionRow(connection.browser_agent_session_id);
+    if (sessionRow && sessionRow.status === "open") {
+      await closeAndSettleSession(sessionRow);
+    }
+  }
+  await markAuthConnectionAuthenticated(connectionId);
+  return { ok: true };
+}
 async function reapIdleBrowserSessions(idleSeconds = 120) {
   const rows = await listIdleOpenSessionRows(idleSeconds);
   let reaped = 0;
   for (const row of rows) {
-    if (row.user_id != null) {
-      try {
-        await charge(row.id, row.user_id);
-      } catch {
-      }
-    }
-    try {
-      await closeSession(row.runtime_session_id);
-    } catch {
-    }
-    await markSessionClosed(row.id).catch(() => {
-    });
-    if (row.concurrency_lock_id) await releaseConcurrencyGate(row.concurrency_lock_id).catch(() => {
-    });
+    await closeAndSettleSession(row);
     reaped++;
   }
   return { reaped };
@@ -16448,81 +17143,94 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono15();
+  const app2 = new Hono16();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
   });
   app2.use("*", auth);
   app2.post("/profiles/onboard", async (c) => {
+    const user = c.get("user");
+    if (Number(user.balance_mc ?? 0) < BROWSER_OPEN_MIN_BALANCE_MC) {
+      return c.json(insufficientBalanceResponse(Number(user.balance_mc ?? 0), BROWSER_OPEN_MIN_BALANCE_MC), 402);
+    }
     const body = await c.req.json().catch(() => ({}));
     const profileName = typeof body.profile === "string" ? body.profile.trim() : "";
     const domain = typeof body.domain === "string" ? body.domain.trim().replace(/^https?:\/\//, "").replace(/\/.*$/, "") : "chatgpt.com";
     const loginUrl = typeof body.login_url === "string" ? body.login_url.trim() : void 0;
     const accountEmail = typeof body.account_email === "string" ? body.account_email.trim() || null : null;
     const note = typeof body.note === "string" ? body.note.trim() || null : null;
+    const timeoutSeconds = typeof body.timeout_seconds === "number" ? body.timeout_seconds : void 0;
     if (!profileName) return c.json({ error: "profile is required" }, 400);
     if (!domain) return c.json({ error: "domain is required" }, 400);
+    const gate = await acquireConcurrencyGate(user, "browser_agent_session", {
+      ttlSeconds: browserSessionLockTtlSeconds(timeoutSeconds),
+      metadata: { label: typeof body.label === "string" ? body.label : null }
+    });
+    if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+    let runtimeSessionId = null;
     try {
-      const result = await startProfileOnboarding({ profileName, domain, loginUrl });
-      try {
-        await saveAuthConnection({
-          connectionId: result.connectionId,
-          hostedUrl: result.hostedUrl,
-          domain: result.domain,
-          profile: result.profileName,
-          accountEmail,
-          note
-        });
-      } catch {
-      }
+      const created = await createSession({
+        timeoutSeconds,
+        profileName,
+        saveProfileChanges: true,
+        startUrl: loginUrl || `https://${domain}/`,
+        disableDefaultProxy: true
+      });
+      runtimeSessionId = created.runtimeSessionId;
+      const sessionRow = await createSessionRow({
+        runtimeSessionId: created.runtimeSessionId,
+        liveViewUrl: created.liveViewUrl,
+        cdpWsUrl: created.cdpWsUrl,
+        label: typeof body.label === "string" ? body.label : `Login setup: ${domain} \u2192 ${profileName}`,
+        userId: user.id,
+        concurrencyLockId: gate.lockId
+      });
+      const connection = await createAuthConnectionRow({
+        domain,
+        profile: profileName,
+        accountEmail,
+        note,
+        browserAgentSessionId: sessionRow.id
+      });
       return c.json({
-        connection_id: result.connectionId,
-        profile: result.profileName,
-        domain: result.domain,
-        status: result.status,
-        flow_status: result.flowStatus,
-        flow_step: result.flowStep,
-        flow_expires_at: result.flowExpiresAt,
-        browser_session_id: result.browserSessionId,
-        post_login_url: result.postLoginUrl
+        connection_id: connection.connection_id,
+        profile: profileName,
+        domain,
+        status: connection.status,
+        browser_session_id: sessionRow.id
       });
     } catch (err) {
+      if (runtimeSessionId) {
+        try {
+          await closeSession(runtimeSessionId);
+        } catch {
+        }
+      }
+      await releaseConcurrencyGate(gate.lockId);
       return c.json(failure(err), 502);
     }
   });
   app2.post("/profiles/status", async (c) => {
     const body = await c.req.json().catch(() => ({}));
-    const connectionId = typeof body.connection_id === "string" ? body.connection_id.trim() : void 0;
-    const profileName = typeof body.profile === "string" ? body.profile.trim() : void 0;
+    const connectionId = typeof body.connection_id === "string" ? body.connection_id.trim() : "";
+    const profileName = typeof body.profile === "string" ? body.profile.trim() : "";
     const domain = typeof body.domain === "string" ? body.domain.trim().replace(/^https?:\/\//, "").replace(/\/.*$/, "") : void 0;
-    try {
-      const result = await getProfileOnboardingStatus({ connectionId, profileName, domain });
-      if (result.hostedUrl) {
-        try {
-          await saveAuthConnection({
-            connectionId: result.connectionId,
-            hostedUrl: result.hostedUrl,
-            domain: result.domain,
-            profile: result.profileName
-          });
-        } catch {
-        }
-      }
-      return c.json({
-        connection_id: result.connectionId,
-        profile: result.profileName,
-        domain: result.domain,
-        status: result.status,
-        flow_status: result.flowStatus,
-        flow_step: result.flowStep,
-        flow_expires_at: result.flowExpiresAt,
-        browser_session_id: result.browserSessionId,
-        post_login_url: result.postLoginUrl
-      });
-    } catch (err) {
-      return c.json(failure(err), 404);
-    }
+    let row = null;
+    if (connectionId) {
+      row = await getAuthConnectionRow(connectionId);
+    } else if (profileName && domain) {
+      const rows = await listAuthConnectionsByProfile(profileName);
+      row = rows.find((r) => r.domain === domain) ?? null;
+    }
+    if (!row) return c.json({ error: "auth connection not found" }, 404);
+    return c.json({
+      connection_id: row.connection_id,
+      profile: row.profile,
+      domain: row.domain,
+      status: row.status,
+      browser_session_id: row.browser_agent_session_id
+    });
   });
   app2.post("/profiles/list", async (c) => {
     const body = await c.req.json().catch(() => ({}));
@@ -16531,23 +17239,15 @@ function buildBrowserAgentRoutes() {
     const domainFilter = typeof body.domain === "string" ? body.domain.trim().replace(/^https?:\/\//, "").replace(/\/.*$/, "") : void 0;
     const connectionIdFilter = typeof body.connection_id === "string" ? body.connection_id.trim() : void 0;
     try {
-      const [live, stored] = await Promise.all([
-        listProfileConnections(profileName),
-        listAuthConnectionsByProfile(profileName).catch(() => [])
-      ]);
-      const notesByDomain = new Map(stored.map((row) => [row.domain ?? "", row]));
-      const notesByConnection = new Map(stored.map((row) => [row.connection_id, row]));
-      let connections = live.map((conn) => {
-        const record = notesByConnection.get(conn.connectionId) ?? notesByDomain.get(conn.domain);
-        return {
-          connection_id: conn.connectionId,
-          domain: conn.domain,
-          status: conn.status,
-          account_email: record?.account_email ?? null,
-          note: record?.note ?? null,
-          last_connected_at: record?.updated_at ?? record?.created_at ?? null
-        };
-      });
+      const stored = await listAuthConnectionsByProfile(profileName);
+      let connections = stored.map((row) => ({
+        connection_id: row.connection_id,
+        domain: row.domain,
+        status: row.status,
+        account_email: row.account_email,
+        note: row.note,
+        last_connected_at: row.updated_at ?? row.created_at
+      }));
       if (connectionIdFilter) connections = connections.filter((c2) => c2.connection_id === connectionIdFilter);
       if (domainFilter) connections = connections.filter((c2) => c2.domain === domainFilter);
       return c.json({ profile: profileName, connections });
@@ -16622,13 +17322,7 @@ function buildBrowserAgentRoutes() {
     const user = c.get("user");
     const row = await loadOpenSession(c.req.param("id"), user.id);
     if (!row) return c.json({ error: "not found" }, 404);
-    await charge(row.id, user.id);
-    try {
-      await closeSession(row.runtime_session_id);
-    } catch {
-    }
-    await markSessionClosed(row.id);
-    await releaseConcurrencyGate(row.concurrency_lock_id);
+    await closeAndSettleSession(row);
     return c.json({ ok: true });
   });
   app2.post("/sessions/:id/goto", async (c) => {
@@ -16912,17 +17606,30 @@ function buildBrowserAgentRoutes() {
 }
 
 // src/api/browser-agent-console.ts
-function renderAuthConsoleHtml(connectionId, hostedUrl) {
-  const safeId = String(connectionId).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
-  const goUrl = `/console/auth/${encodeURIComponent(connectionId)}/go`;
-  const body = hostedUrl ? `<iframe class="stage" allow="clipboard-read; clipboard-write" src="${goUrl}"></iframe>
-       <div class="fallback">
-         <span>Sign-in window not showing?</span>
-         <a class="btn" href="${goUrl}" target="_blank" rel="noopener">Open sign-in in a new tab</a>
-       </div>` : `<div class="empty">
+function renderAuthConsoleHtml(connectionId, info) {
+  const esc = (s) => String(s == null ? "" : s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+  const safeId = esc(connectionId);
+  const domainLabel = info.domain ? esc(info.domain) : "this site";
+  let body;
+  if (info.status === "AUTHENTICATED") {
+    body = `<div class="empty">
+      <div class="check">\u2713</div>
+      <div>You're signed in to ${domainLabel}.</div>
+      <div class="muted">This login is saved. You can close this tab.</div>
+    </div>`;
+  } else if (info.sessionOpen && info.liveViewUrl) {
+    body = `<iframe class="stage" allow="clipboard-read; clipboard-write" src="${esc(info.liveViewUrl)}"></iframe>
+       <div class="footer">
+         <span class="muted">Log into ${domainLabel} directly in the window above, then confirm below.</span>
+         <span class="spacer"></span>
+         <button class="btn" id="done">Done \u2014 I'm signed in</button>
+       </div>`;
+  } else {
+    body = `<div class="empty">
          <div>This sign-in link is no longer active.</div>
          <div class="muted">Ask the assistant to reconnect the profile, then open the new link.</div>
        </div>`;
+  }
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -16938,9 +17645,11 @@ function renderAuthConsoleHtml(connectionId, hostedUrl) {
   header .muted { color: #6b7689; font-size: 12px; }
   .spacer { flex: 1; }
   .stage { flex: 1; width: 100%; border: 0; display: block; background: #05070b; }
-  .fallback { display: flex; align-items: center; gap: 12px; padding: 10px 18px; border-top: 1px solid #1c2230; background: #0f131c; font-size: 13px; color: #8893a7; }
-  .btn { background: #2b6cff; color: #fff; border-radius: 7px; padding: 7px 12px; text-decoration: none; font-weight: 500; }
+  .footer { display: flex; align-items: center; gap: 12px; padding: 10px 18px; border-top: 1px solid #1c2230; background: #0f131c; font-size: 13px; color: #8893a7; }
+  .btn { background: #2b6cff; color: #fff; border: 0; border-radius: 7px; padding: 8px 14px; text-decoration: none; font-weight: 500; font: inherit; cursor: pointer; }
+  .btn:disabled { opacity: .6; cursor: default; }
   .empty { flex: 1; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; color: #8893a7; }
+  .check { font-size: 32px; color: #36d399; }
   .muted { color: #6b7689; font-size: 12px; }
 </style>
 ${ATTRIBUTION_PIXEL_SCRIPT}
@@ -16950,9 +17659,23 @@ ${ATTRIBUTION_PIXEL_SCRIPT}
   <h1>MCP Scraper</h1>
   <span class="muted">Secure sign-in \xB7 ${safeId}</span>
   <span class="spacer"></span>
-  <span class="muted">Complete the login below \u2014 your session is saved to your profile.</span>
+  <span class="muted">Log in directly to the real site above \u2014 your session is saved to your profile.</span>
 </header>
 ${body}
+<script>
+(function(){
+  var doneBtn = document.getElementById('done');
+  if (!doneBtn) return;
+  doneBtn.onclick = function() {
+    doneBtn.disabled = true;
+    doneBtn.textContent = 'Saving\u2026';
+    fetch('/console/auth/${encodeURIComponent(connectionId)}/complete', { method: 'POST' })
+      .then(function(r){ return r.json().catch(function(){ return {}; }); })
+      .then(function(){ location.reload(); })
+      .catch(function(){ doneBtn.disabled = false; doneBtn.textContent = "Done \u2014 I'm signed in"; });
+  };
+})();
+</script>
 </body>
 </html>`;
 }
@@ -17154,9 +17877,9 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono17 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono16();
+var stripeApp = new Hono17();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -17190,8 +17913,9 @@ stripeApp.post("/webhooks", async (c) => {
       const user2 = await resolveUser(sub.customer, sub.customer_email);
       if (user2) {
         const live = sub.status === "active" || sub.status === "trialing";
-        await setMemoryPlan(user2.id, live ? mem.plan : "free", live ? sub.id : null);
-        await syncMemoryKeyPlan(user2, live ? mem.plan : "free");
+        const newMemoryPlan = live ? mem.plan : "free";
+        await setMemoryPlan(user2.id, newMemoryPlan, live ? sub.id : null);
+        await syncMemoryKeyPlan(user2, resolveEffectiveMemoryPlan({ ...user2, memory_plan: newMemoryPlan }));
       }
       return c.json({ received: true });
     }
@@ -17209,7 +17933,9 @@ stripeApp.post("/webhooks", async (c) => {
     if (priceId && priceId in SUBSCRIPTION_TIERS) {
       const tier = SUBSCRIPTION_TIERS[priceId];
       const live = sub.status === "active" || sub.status === "trialing";
-      await setSubscriptionTier(user.id, live ? tier.tier : null, live ? tier.concurrency : 0, live ? sub.id : null);
+      const newTier = live ? tier.tier : null;
+      await setSubscriptionTier(user.id, newTier, live ? tier.concurrency : 0, live ? sub.id : null);
+      await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, subscription_tier: newTier }));
     } else if (priceId === CONCURRENCY_PRICE_ID && event.type === "customer.subscription.created") {
       await setExtraConcurrencySlots(user.id, user.extra_concurrency_slots + 1);
       await setConcurrencySubId(user.id, sub.id);
@@ -17222,7 +17948,7 @@ stripeApp.post("/webhooks", async (c) => {
       const user2 = await resolveUserByMemorySubscription(sub.id) ?? await getUserByStripeCustomerId(sub.customer);
       if (user2) {
         await setMemoryPlan(user2.id, "free", null);
-        await syncMemoryKeyPlan(user2, "free");
+        await syncMemoryKeyPlan(user2, resolveEffectiveMemoryPlan({ ...user2, memory_plan: "free" }));
       }
       return c.json({ received: true });
     }
@@ -17235,6 +17961,7 @@ stripeApp.post("/webhooks", async (c) => {
     if (!user) return c.json({ received: true });
     if (priceId && priceId in SUBSCRIPTION_TIERS) {
       await setSubscriptionTier(user.id, null, 0, null);
+      await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, subscription_tier: null }));
     } else if (priceId === CONCURRENCY_PRICE_ID) {
       await setExtraConcurrencySlots(user.id, Math.max(0, user.extra_concurrency_slots - 1));
       await setConcurrencySubId(user.id, null);
@@ -17256,7 +17983,7 @@ async function resolveUser(customerId, emailFallback) {
 }
 
 // src/api/oauth-routes.ts
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono18 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
 import { createHash as createHash3, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
@@ -17425,7 +18152,7 @@ function redirectWithError(redirectUri, state, error) {
   if (state) u.searchParams.set("state", state);
   return new Response(null, { status: 302, headers: { Location: u.toString() } });
 }
-var oauthApp = new Hono17();
+var oauthApp = new Hono18();
 oauthApp.use("*", async (c, next) => {
   c.header("Access-Control-Allow-Origin", "*");
   c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -17679,8 +18406,8 @@ oauthApp.post("/oauth/token", async (c) => {
 });
 
 // src/api/chat-routes.ts
-import { Hono as Hono18 } from "hono";
-var chatApp = new Hono18();
+import { Hono as Hono19 } from "hono";
+var chatApp = new Hono19();
 function tokenOk(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -18350,8 +19077,8 @@ loadChannels();
 }
 
 // src/api/schedule-routes.ts
-import { Hono as Hono19 } from "hono";
-var scheduleApp = new Hono19();
+import { Hono as Hono20 } from "hono";
+var scheduleApp = new Hono20();
 function tokenOk2(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -19106,7 +19833,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono20();
+var app = new Hono21();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -20467,7 +21194,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-RVZXIALX.js");
+  const { drainQueue } = await import("./worker-7XRZNLKB.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] = await Promise.all([
@@ -20485,7 +21212,7 @@ 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-2MQBAOX5.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-4NVO5KQA.js");
   const { assembleExtractArtifacts } = await import("./extract-bundle-UKE273TV.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
@@ -20493,7 +21220,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   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-2MQBAOX5.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-4NVO5KQA.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -20519,6 +21246,7 @@ app.route("/instagram", instagramApp);
 app.route("/reddit", redditApp);
 app.route("/video", videoApp);
 app.route("/maps", mapsApp);
+app.route("/trustpilot", trustpilotApp);
 app.route("/directory", directoryApp);
 app.route("/workflows", workflowApp);
 app.route("/serp-intelligence", serpIntelligenceApp);
@@ -20531,14 +21259,20 @@ app.get("/console/auth/:id", async (c) => {
   const id = c.req.param("id");
   await migrateBrowserAgent();
   const row = await getAuthConnectionRow(id);
-  return c.html(renderAuthConsoleHtml(id, row?.hosted_url ?? null));
+  const sessionRow = row?.browser_agent_session_id ? await getSessionRow(row.browser_agent_session_id) : null;
+  return c.html(renderAuthConsoleHtml(id, {
+    domain: row?.domain ?? null,
+    status: row?.status ?? null,
+    liveViewUrl: sessionRow?.live_view_url ?? null,
+    sessionOpen: sessionRow?.status === "open"
+  }));
 });
-app.get("/console/auth/:id/go", async (c) => {
+app.post("/console/auth/:id/complete", async (c) => {
   const id = c.req.param("id");
   await migrateBrowserAgent();
-  const row = await getAuthConnectionRow(id);
-  if (!row?.hosted_url) return c.text("This sign-in link is no longer active.", 404);
-  return c.redirect(row.hosted_url, 302);
+  const result = await completeAuthConnection(id);
+  if (!result.ok) return c.json({ error: result.error }, 404);
+  return c.json({ ok: true });
 });
 app.get("/console/:id", (c) => c.html(renderConsoleHtml(c.req.param("id"))));
 app.route("/stripe", stripeApp);
@@ -20649,4 +21383,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-U7V6DUSY.js.map
+//# sourceMappingURL=server-LBEYRKM2.js.map