mcp-scraper 0.3.28 → 0.3.42

package/dist/{server-IDDX7KGT.js → server-CZT7EULY.js}

@@ -16,7 +16,7 @@ import {
   renderLinkReport,
   sanitizeAttempts,
   sanitizeHarvestResult
-} from "./chunk-NGD4ITAO.js";
+} from "./chunk-KPF64WST.js";
 import {
   csvRecords,
   listWorkflowDefinitions,
@@ -29,7 +29,7 @@ import {
   workflowStepCount,
   workflowSupportsSteps
 } from "./chunk-NNEIXK5L.js";
-import "./chunk-7MY2NSQX.js";
+import "./chunk-OUZZNW3I.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -40,6 +40,7 @@ import {
   MC_PER_CREDIT,
   MEMORY_PLANS,
   MEMORY_PLAN_QUOTA,
+  SCHEDULING_PLANS,
   SUBSCRIPTION_TIERS,
   SUBSCRIPTION_TIER_BY_KEY,
   browserActiveCostMc,
@@ -49,7 +50,7 @@ import {
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-H74L743B.js";
+} from "./chunk-RXJHXBGG.js";
 import {
   BrowserDriver,
   MapsSelectors,
@@ -62,7 +63,7 @@ import {
   recordVendorUsage,
   resolveKernelProxyId,
   runWithCostContext
-} from "./chunk-QSSH4RCX.js";
+} from "./chunk-GMTS35L6.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -158,7 +159,7 @@ import {
   setSubscriptionTier,
   setUserMemoryCreds,
   verifyPassword
-} from "./chunk-TRNSXR46.js";
+} from "./chunk-DVRPXPYH.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -3547,7 +3548,7 @@ async function fetchWithKernel(url) {
     });
     await client2.browsers.deleteByID(kb.session_id).catch(() => {
     });
-    void recordKernelSession({ kernelSessionId: kb.session_id, source: "kernel_fetch", stealth: typeof kb.stealth === "boolean" ? kb.stealth : null, headlessSent: useHeadless ? true : null, proxyUsed: typeof kb.proxy_id === "string" ? Boolean(kb.proxy_id) : null, fallback: true, openedAtMs, closedAtMs: Date.now() });
+    void recordKernelSession({ kernelSessionId: kb.session_id, source: "kernel_fetch", stealth: typeof kb.stealth === "boolean" ? kb.stealth : null, headlessSent: useHeadless, proxyUsed: typeof kb.proxy_id === "string" ? Boolean(kb.proxy_id) : null, fallback: true, openedAtMs, closedAtMs: Date.now() });
   }
 }
 
@@ -5256,7 +5257,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono18 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -7805,6 +7806,49 @@ var CATALOG = {
         }
       ]
     },
+    {
+      key: "google_ads",
+      label: "Google Ads",
+      icon: "megaphone",
+      tools: [
+        {
+          key: "google_ads_search",
+          label: "Ad Search",
+          kind: "simple",
+          endpoint: "/google-ads/search",
+          mcpName: "google_ads_search",
+          tagline: "Find advertisers in Ads Transparency",
+          params: [
+            { key: "query", label: "Domain or advertiser", type: "string", required: true, placeholder: "getviktor.com" },
+            { key: "region", label: "Region", type: "string", default: "US" },
+            { key: "maxResults", label: "Max results", type: "number", min: 1, max: 20, default: 10, advanced: true }
+          ],
+          examples: ["Find Google ads pointing to this domain"]
+        },
+        {
+          key: "google_ads_page_intel",
+          label: "Advertiser Intel",
+          kind: "simple",
+          endpoint: "/google-ads/page-intel",
+          mcpName: "google_ads_page_intel",
+          tagline: "An advertiser's ad creatives + media",
+          params: [
+            { key: "domain", label: "Domain or advertiser ID", type: "string", required: true, placeholder: "getviktor.com" },
+            { key: "region", label: "Region", type: "string", default: "US" },
+            { key: "maxAds", label: "Max ads", type: "number", min: 1, max: 200, default: 50, advanced: true }
+          ]
+        },
+        {
+          key: "google_ads_transcribe",
+          label: "Ad Transcribe",
+          kind: "simple",
+          endpoint: "/google-ads/transcribe",
+          mcpName: "google_ads_transcribe",
+          tagline: "Transcribe a video ad",
+          params: [{ ...URL_PARAM, label: "Ad video URL" }]
+        }
+      ]
+    },
     {
       key: "instagram",
       label: "Instagram",
@@ -10790,9 +10834,330 @@ facebookAdApp.post("/media", createApiKeyAuth(), async (c) => {
   });
 });
 
-// src/api/instagram-routes.ts
+// src/api/google-ads-routes.ts
 import { Hono as Hono5 } from "hono";
 import { z as z14 } from "zod";
+
+// src/extractor/GoogleAdsExtractor.ts
+var ORIGIN = "https://adstransparency.google.com";
+function looksLikeDomain(q) {
+  return /^[a-z0-9.-]+\.[a-z]{2,}$/i.test(q.trim()) && !q.includes(" ");
+}
+var GoogleAdsExtractor = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  page() {
+    return this.driver.getPage();
+  }
+  async search(query, region, maxResults) {
+    const q = query.trim();
+    const url = looksLikeDomain(q) ? `${ORIGIN}/?region=${encodeURIComponent(region)}&domain=${encodeURIComponent(q)}` : `${ORIGIN}/?region=${encodeURIComponent(region)}&query=${encodeURIComponent(q)}`;
+    await this.driver.navigateTo(url);
+    const page = this.page();
+    await page.waitForTimeout(3500);
+    await this.autoScroll(page, 6);
+    const advertisers = await page.evaluate((max) => {
+      const map = /* @__PURE__ */ new Map();
+      const links = Array.from(document.querySelectorAll('a[href*="/advertiser/"]'));
+      for (const a of links) {
+        const m = a.getAttribute("href")?.match(/\/advertiser\/(AR[0-9]+)/);
+        if (!m) continue;
+        const id = m[1];
+        const card = a.closest("creative-preview, advertiser-preview") || a.parentElement;
+        const nameEl = card?.querySelector('[class*="advertiser"], [class*="name"]');
+        const name = (nameEl?.innerText || "").trim() || null;
+        const cur = map.get(id);
+        if (cur) cur.count++;
+        else map.set(id, { advertiserId: id, name, count: 1 });
+      }
+      return Array.from(map.values()).slice(0, max).map((v) => ({
+        advertiserId: v.advertiserId,
+        name: v.name,
+        approxAdCount: v.count
+      }));
+    }, maxResults);
+    return {
+      query: q,
+      region,
+      advertiserCount: advertisers.length,
+      advertisers: advertisers.map((a) => ({
+        advertiserId: a.advertiserId,
+        name: a.name,
+        domain: looksLikeDomain(q) ? q : null,
+        approxAdCount: a.approxAdCount,
+        detailUrl: `${ORIGIN}/advertiser/${a.advertiserId}?region=${region}`
+      }))
+    };
+  }
+  async pageIntel(opts) {
+    const { region, maxAds } = opts;
+    let advertiserId = opts.advertiserId?.trim() || null;
+    if (!advertiserId && opts.domain) {
+      const s = await this.search(opts.domain, region, 1);
+      advertiserId = s.advertisers[0]?.advertiserId ?? null;
+    }
+    if (!advertiserId) {
+      return { advertiserId: null, advertiserName: null, domain: opts.domain ?? null, region, totalCreatives: 0, videoCount: 0, imageCount: 0, textCount: 0, ads: [] };
+    }
+    const listUrl = `${ORIGIN}/advertiser/${advertiserId}?region=${region}`;
+    await this.driver.navigateTo(listUrl);
+    const page = this.page();
+    await page.waitForTimeout(3500);
+    await this.autoScroll(page, 10);
+    const listing = await page.evaluate(() => {
+      const nameEl = document.querySelector('h1, [class*="advertiser-name"]');
+      const advertiserName = (nameEl?.innerText || "").trim() || null;
+      const ids = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const a of Array.from(document.querySelectorAll('a[href*="/creative/"]'))) {
+        const m = a.getAttribute("href")?.match(/\/creative\/(CR[0-9]+)/);
+        if (m && !seen.has(m[1])) {
+          seen.add(m[1]);
+          ids.push(m[1]);
+        }
+      }
+      return { advertiserName, creativeIds: ids };
+    });
+    const creativeIds = listing.creativeIds.slice(0, maxAds);
+    const ads = [];
+    for (const creativeId of creativeIds) {
+      try {
+        const hydrated = await this.hydrateCreative(page, advertiserId, creativeId);
+        ads.push({
+          creativeId,
+          advertiserId,
+          detailUrl: `${ORIGIN}/advertiser/${advertiserId}/creative/${creativeId}?region=${region}`,
+          ...hydrated
+        });
+      } catch {
+        ads.push({
+          creativeId,
+          advertiserId,
+          detailUrl: `${ORIGIN}/advertiser/${advertiserId}/creative/${creativeId}?region=${region}`,
+          format: null,
+          lastShown: null,
+          landingDomain: null,
+          imageUrls: [],
+          youtubeVideoId: null,
+          videoUrl: null,
+          variations: null
+        });
+      }
+    }
+    const videoCount = ads.filter((a) => a.format === "video").length;
+    const imageCount = ads.filter((a) => a.format === "image").length;
+    const textCount = ads.filter((a) => a.format === "text").length;
+    return {
+      advertiserId,
+      advertiserName: listing.advertiserName,
+      domain: opts.domain ?? null,
+      region,
+      totalCreatives: ads.length,
+      videoCount,
+      imageCount,
+      textCount,
+      ads
+    };
+  }
+  async hydrateCreative(page, advertiserId, creativeId) {
+    return page.evaluate(async ({ advertiserId: advertiserId2, creativeId: creativeId2 }) => {
+      const empty = { format: null, lastShown: null, landingDomain: null, imageUrls: [], youtubeVideoId: null, videoUrl: null, variations: null };
+      const rpcUrl = "https://adstransparency.google.com/anji/_/rpc/LookupService/GetCreativeById?authuser=0";
+      const payload = { "1": advertiserId2, "2": creativeId2, "5": { "1": 1, "2": 1 } };
+      const resp = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded", "x-same-domain": "1" },
+        body: "f.req=" + encodeURIComponent(JSON.stringify(payload)),
+        credentials: "include"
+      }).then((r) => r.text()).catch(() => "");
+      if (!resp) return empty;
+      const decode = (s) => s.replace(/\\u002f/gi, "/").replace(/\\u([0-9a-fA-F]{4})/g, (_m, h) => String.fromCharCode(parseInt(h, 16)));
+      const previewUrls = Array.from(resp.matchAll(/https:(?:\\u002f\\u002f|\/\/)[^"\\]*content\.js(?:[^"\\]|\\u[0-9a-fA-F]{4})*/g)).map((m) => decode(m[0]));
+      const variations = previewUrls.length || null;
+      let imageUrls = [];
+      let youtubeVideoId = null;
+      let videoUrl = null;
+      const previewUrl = previewUrls[0];
+      if (previewUrl) {
+        const rendered = await fetch(previewUrl, { credentials: "omit" }).then((r) => r.text()).catch(() => "");
+        const yt = rendered.match(/i\.ytimg\.com\/vi\/([A-Za-z0-9_-]{11})/);
+        if (yt) youtubeVideoId = yt[1];
+        const gv = rendered.match(/https:\/\/[a-z0-9-]+\.googlevideo\.com\/videoplayback[^"'\\ ]+/);
+        if (gv) videoUrl = gv[0].replace(/\\u0026/g, "&").replace(/\\u003d/g, "=");
+        const simgads = Array.from(rendered.matchAll(/(?:tpc\.googlesyndication\.com\/(?:archive\/)?simgad\/|\/simgad\/)([0-9]+)/g)).map((m) => "https://tpc.googlesyndication.com/simgad/" + m[1]);
+        imageUrls = Array.from(new Set(simgads)).slice(0, 8);
+      }
+      const format = youtubeVideoId || videoUrl ? "video" : imageUrls.length ? "image" : "text";
+      return { format, lastShown: null, landingDomain: null, imageUrls, youtubeVideoId, videoUrl, variations };
+    }, { advertiserId, creativeId });
+  }
+  async autoScroll(page, rounds) {
+    for (let i = 0; i < rounds; i++) {
+      await page.evaluate(() => {
+        if (document.scrollingElement) window.scrollTo(0, document.scrollingElement.scrollHeight);
+      }).catch(() => {
+      });
+      await page.waitForTimeout(700);
+    }
+  }
+};
+
+// src/api/google-ads-routes.ts
+import { fal as fal4 } from "@fal-ai/client";
+var GoogleAdsSearchBodySchema = z14.object({
+  query: z14.string().trim().min(1, "query is required"),
+  region: z14.string().trim().toUpperCase().length(2).optional(),
+  maxResults: z14.number().int().min(1).max(20).optional()
+});
+var GoogleAdsPageIntelBodySchema = z14.object({
+  advertiserId: z14.string().trim().optional(),
+  domain: z14.string().trim().optional(),
+  region: z14.string().trim().toUpperCase().length(2).optional(),
+  maxAds: z14.number().int().min(1).max(200).optional()
+}).refine((d) => !!d.advertiserId || !!d.domain, { message: "advertiserId or domain is required" });
+var GoogleAdsTranscribeBodySchema = z14.object({
+  videoUrl: z14.string().trim().min(1, "videoUrl is required")
+});
+function invalidRequest2(message) {
+  return { error_code: "invalid_request", message };
+}
+function configuredKernelProxy2() {
+  return (process.env.BROWSER_SERVICE_PROXY_ID ?? process.env.KERNEL_PROXY_ID)?.trim() || void 0;
+}
+async function kernelLaunchOptsResidential2() {
+  let proxyId = configuredKernelProxy2();
+  try {
+    const resolution = await resolveKernelProxyId({
+      kernelApiKey: browserServiceApiKey(),
+      proxyMode: DEFAULT_PROXY_MODE,
+      configuredKernelProxyId: configuredKernelProxy2(),
+      gl: "us"
+    });
+    if (resolution.kernelProxyId) proxyId = resolution.kernelProxyId;
+  } catch {
+    proxyId = configuredKernelProxy2();
+  }
+  return { headless: true, kernelApiKey: browserServiceApiKey(), kernelProxyId: proxyId, viewport: { width: 1280, height: 900 }, locale: "en-US" };
+}
+function isBlockedMessage(msg) {
+  return msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha");
+}
+var googleAdsApp = new Hono5();
+googleAdsApp.post("/search", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = GoogleAdsSearchBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const region = body.region ?? "US";
+  const maxResults = Math.min(20, Math.max(1, body.maxResults ?? 10));
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "google_ads_search", { reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"), metadata: { query: body.query.trim(), region } });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  const driver = new BrowserDriver();
+  let debited = false, refunded = false;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.google_ads_search, LedgerOperation.GOOGLE_ADS_SEARCH, body.query.trim());
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.google_ads_search), 402);
+    debited = true;
+    await driver.launch(await kernelLaunchOptsResidential2());
+    const extractor = new GoogleAdsExtractor(driver);
+    const result = await extractor.search(body.query.trim(), region, maxResults);
+    if (result.advertisers.length === 0) {
+      await creditMc(user.id, MC_COSTS.google_ads_search, LedgerOperation.GOOGLE_ADS_SEARCH_REFUND, "empty result");
+      refunded = true;
+      await logRequestEvent({ userId: user.id, source: "google_ads_search", status: "failed", query: body.query.trim(), error: "empty result refunded" });
+      return c.json({ error: "no advertisers found (refunded)" }, 503);
+    }
+    await logRequestEvent({ userId: user.id, source: "google_ads_search", status: "done", query: body.query.trim(), resultCount: result.advertisers.length, result });
+    return c.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (debited && !refunded) await creditMc(user.id, MC_COSTS.google_ads_search, LedgerOperation.GOOGLE_ADS_SEARCH_REFUND, "failed call");
+    await logRequestEvent({ userId: user.id, source: "google_ads_search", status: "failed", query: body.query.trim(), error: msg });
+    return c.json({ error: msg }, isBlockedMessage(msg) ? 503 : 500);
+  } finally {
+    await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+googleAdsApp.post("/page-intel", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = GoogleAdsPageIntelBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const region = body.region ?? "US";
+  const maxAds = Math.min(200, Math.max(1, body.maxAds ?? 50));
+  const queryLabel = body.advertiserId ?? body.domain ?? "";
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "google_ads_page_intel", { reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"), metadata: { advertiserId: body.advertiserId, domain: body.domain, region } });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  const driver = new BrowserDriver();
+  let debited = false, refunded = false;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.google_ads_intel, LedgerOperation.GOOGLE_ADS_INTEL, queryLabel);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.google_ads_intel), 402);
+    debited = true;
+    await driver.launch(await kernelLaunchOptsResidential2());
+    const extractor = new GoogleAdsExtractor(driver);
+    const result = await extractor.pageIntel({ advertiserId: body.advertiserId, domain: body.domain, region, maxAds });
+    if (result.ads.length === 0) {
+      await creditMc(user.id, MC_COSTS.google_ads_intel, LedgerOperation.GOOGLE_ADS_INTEL_REFUND, "empty result");
+      refunded = true;
+      await logRequestEvent({ userId: user.id, source: "google_ads_page_intel", status: "failed", query: queryLabel, error: "empty result refunded" });
+      return c.json({ error: "no ads found for this advertiser/domain (refunded)" }, 503);
+    }
+    await logRequestEvent({ userId: user.id, source: "google_ads_page_intel", status: "done", query: queryLabel, resultCount: result.ads.length, result });
+    return c.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (debited && !refunded) await creditMc(user.id, MC_COSTS.google_ads_intel, LedgerOperation.GOOGLE_ADS_INTEL_REFUND, "failed call");
+    await logRequestEvent({ userId: user.id, source: "google_ads_page_intel", status: "failed", query: queryLabel, error: msg });
+    return c.json({ error: msg }, isBlockedMessage(msg) ? 503 : 500);
+  } finally {
+    await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+googleAdsApp.post("/transcribe", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = GoogleAdsTranscribeBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const urlCheck = await validatePublicHttpUrl(body.videoUrl, { field: "videoUrl", requireHttps: false });
+  if (urlCheck.error) return c.json(invalidRequest2(urlCheck.error), 400);
+  const videoUrl = urlCheck.parsed.href;
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "google_ads_transcribe", { reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"), metadata: { videoUrl } });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  fal4.config({ credentials: process.env.FAL_KEY });
+  const holdMc = MC_COSTS.google_ads_transcribe * 5;
+  let debited = false;
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, holdMc, LedgerOperation.GOOGLE_ADS_TRANSCRIBE, videoUrl);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, holdMc), 402);
+    debited = true;
+    const transcript = await transcribeMediaUrl(videoUrl, "# Google Ad Transcript");
+    const actualMins = Math.max(1, Math.ceil((Number.isFinite(transcript.durationMs) ? transcript.durationMs / 1e3 : 60) / 60));
+    const diff = holdMc - MC_COSTS.google_ads_transcribe * actualMins;
+    if (diff > 0) await creditMc(user.id, diff, LedgerOperation.GOOGLE_ADS_TRANSCRIBE_REFUND, "overestimate refund");
+    else if (diff < 0) await debitMc(user.id, -diff, LedgerOperation.GOOGLE_ADS_TRANSCRIBE, videoUrl);
+    await logRequestEvent({ userId: user.id, source: "google_ads_transcribe", status: "done", query: videoUrl, resultCount: transcript.chunks.length, result: { text: transcript.text, chunks: transcript.chunks, durationMs: transcript.durationMs } });
+    return c.json(transcript);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (debited) await creditMc(user.id, holdMc, LedgerOperation.GOOGLE_ADS_TRANSCRIBE_REFUND, "failed call");
+    await logRequestEvent({ userId: user.id, source: "google_ads_transcribe", status: "failed", query: videoUrl, error: msg });
+    return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
+
+// src/api/instagram-routes.ts
+import { Hono as Hono6 } from "hono";
+import { z as z15 } from "zod";
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join5 } from "path";
@@ -11156,33 +11521,33 @@ async function extractInstagramMediaFromPage(page, sourceUrl, capturedMediaUrls
 }
 
 // src/api/instagram-routes.ts
-var InstagramProfileContentBodySchema = z14.object({
-  handle: z14.string().trim().optional(),
-  url: z14.string().trim().optional(),
-  profile: z14.string().trim().min(1).optional(),
-  saveProfileChanges: z14.boolean().optional(),
-  save_profile_changes: z14.boolean().optional(),
-  maxItems: z14.number().int().min(1).max(2e3).default(50),
-  maxScrolls: z14.number().int().min(0).max(250).default(10),
-  scrollDelayMs: z14.number().int().min(250).max(5e3).default(1200),
-  stableScrollLimit: z14.number().int().min(1).max(10).default(4)
+var InstagramProfileContentBodySchema = z15.object({
+  handle: z15.string().trim().optional(),
+  url: z15.string().trim().optional(),
+  profile: z15.string().trim().min(1).optional(),
+  saveProfileChanges: z15.boolean().optional(),
+  save_profile_changes: z15.boolean().optional(),
+  maxItems: z15.number().int().min(1).max(2e3).default(50),
+  maxScrolls: z15.number().int().min(0).max(250).default(10),
+  scrollDelayMs: z15.number().int().min(250).max(5e3).default(1200),
+  stableScrollLimit: z15.number().int().min(1).max(10).default(4)
 }).refine((d) => !!d.handle || !!d.url, {
   message: "handle or url is required"
 });
-var InstagramMediaTypeSchema = z14.enum(["image", "video", "audio"]);
-var InstagramMediaDownloadBodySchema = z14.object({
-  url: z14.string().trim().min(1, "url is required"),
-  profile: z14.string().trim().min(1).optional(),
-  saveProfileChanges: z14.boolean().optional(),
-  save_profile_changes: z14.boolean().optional(),
-  mediaTypes: z14.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
-  downloadMedia: z14.boolean().default(true),
-  downloadAllTracks: z14.boolean().default(false),
-  includeTranscript: z14.boolean().default(false),
-  mux: z14.boolean().default(true)
+var InstagramMediaTypeSchema = z15.enum(["image", "video", "audio"]);
+var InstagramMediaDownloadBodySchema = z15.object({
+  url: z15.string().trim().min(1, "url is required"),
+  profile: z15.string().trim().min(1).optional(),
+  saveProfileChanges: z15.boolean().optional(),
+  save_profile_changes: z15.boolean().optional(),
+  mediaTypes: z15.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
+  downloadMedia: z15.boolean().default(true),
+  downloadAllTracks: z15.boolean().default(false),
+  includeTranscript: z15.boolean().default(false),
+  mux: z15.boolean().default(true)
 });
-var instagramApp = new Hono5();
-function invalidRequest2(message) {
+var instagramApp = new Hono6();
+function invalidRequest3(message) {
   return { error_code: "invalid_request", message };
 }
 function resolveSaveProfileChanges(body) {
@@ -11192,14 +11557,14 @@ function resolveProfileName(body) {
   const explicit = body.profile?.trim();
   return explicit || browserServiceProfileName();
 }
-function configuredKernelProxy2() {
+function configuredKernelProxy3() {
   return (process.env.BROWSER_SERVICE_PROXY_ID ?? process.env.KERNEL_PROXY_ID)?.trim() || void 0;
 }
 async function kernelLaunchOptsDirect(profileName, saveProfileChanges) {
   return {
     headless: true,
     kernelApiKey: browserServiceApiKey(),
-    kernelProxyId: configuredKernelProxy2(),
+    kernelProxyId: configuredKernelProxy3(),
     ...profileName ? { kernelProfileName: profileName } : {},
     ...typeof saveProfileChanges === "boolean" ? { kernelProfileSaveChanges: saveProfileChanges } : {},
     viewport: { width: 1280, height: 900 },
@@ -11285,13 +11650,13 @@ function trackFilename(track, index, shortcode) {
 instagramApp.post("/profile-content", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = InstagramProfileContentBodySchema.safeParse(raw);
-  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  if (!parsed.success) return c.json(invalidRequest3(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
   const body = parsed.data;
   let target;
   try {
     target = normalizeInstagramProfileInput(body.url ?? body.handle ?? "");
   } catch (err) {
-    return c.json(invalidRequest2(err instanceof Error ? err.message : String(err)), 400);
+    return c.json(invalidRequest3(err instanceof Error ? err.message : String(err)), 400);
   }
   const user = c.get("user");
   const gate = await acquireConcurrencyGate(user, "instagram_profile_content", {
@@ -11333,12 +11698,12 @@ instagramApp.post("/profile-content", createApiKeyAuth(), async (c) => {
 instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = InstagramMediaDownloadBodySchema.safeParse(raw);
-  if (!parsed.success) return c.json(invalidRequest2(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  if (!parsed.success) return c.json(invalidRequest3(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
   const body = parsed.data;
   const urlCheck = await validatePublicHttpUrl(body.url, { field: "url", requireHttps: false });
-  if (urlCheck.error) return c.json(invalidRequest2(urlCheck.error), 400);
+  if (urlCheck.error) return c.json(invalidRequest3(urlCheck.error), 400);
   const sourceUrl = urlCheck.parsed;
-  if (!isAllowedInstagramPageUrl(sourceUrl)) return c.json(invalidRequest2("url must be an Instagram post, reel, or tv URL"), 400);
+  if (!isAllowedInstagramPageUrl(sourceUrl)) return c.json(invalidRequest3("url must be an Instagram post, reel, or tv URL"), 400);
   const user = c.get("user");
   const gate = await acquireConcurrencyGate(user, "instagram_media_download", {
     reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
@@ -11455,13 +11820,13 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/reddit-routes.ts
-import { Hono as Hono6 } from "hono";
-import { z as z15 } from "zod";
-var RedditThreadBodySchema = z15.object({
-  url: z15.string().trim().min(1, "url is required"),
-  maxComments: z15.number().int().min(1).max(2e3).optional()
+import { Hono as Hono7 } from "hono";
+import { z as z16 } from "zod";
+var RedditThreadBodySchema = z16.object({
+  url: z16.string().trim().min(1, "url is required"),
+  maxComments: z16.number().int().min(1).max(2e3).optional()
 });
-function invalidRequest3(message) {
+function invalidRequest4(message) {
   return { error_code: "invalid_request", message };
 }
 function toOldReddit(url) {
@@ -11515,14 +11880,14 @@ var PARSE_REDDIT = `(() => {
   });
   return { title: title, author: author, score: score, postBody: postBody, blocked: blocked, numComments: comments.length, comments: comments };
 })()`;
-var redditApp = new Hono6();
+var redditApp = new Hono7();
 redditApp.post("/thread", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = RedditThreadBodySchema.safeParse(raw);
-  if (!parsed.success) return c.json(invalidRequest3(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  if (!parsed.success) return c.json(invalidRequest4(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
   const body = parsed.data;
   const oldUrl = toOldReddit(body.url);
-  if (!oldUrl) return c.json(invalidRequest3("url must be a reddit.com link"), 400);
+  if (!oldUrl) return c.json(invalidRequest4("url must be a reddit.com link"), 400);
   const user = c.get("user");
   const gate = await acquireConcurrencyGate(user, "reddit_thread", {
     reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
@@ -11583,7 +11948,7 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/maps-routes.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 
 // src/extractor/MapsNavigator.ts
 var MapsNavigator = class {
@@ -11758,7 +12123,7 @@ var MapsReviewCollector = class {
 };
 
 // src/extractor/MapsExtractor.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var MapsExtractor = class {
   constructor(driver) {
     this.driver = driver;
@@ -11944,7 +12309,7 @@ var MapsExtractor = class {
       });
       return rows;
     }, { hoursTable: MapsSelectors.hoursTable, hoursTableAlt: MapsSelectors.hoursTableAlt });
-    const result = z16.array(RawMapsHoursRowSchema).safeParse(raw);
+    const result = z17.array(RawMapsHoursRowSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] hours parse failed", result.error.flatten());
       return [];
@@ -12008,7 +12373,7 @@ var MapsExtractor = class {
       });
       return results;
     });
-    const result = z16.array(RawMapsAboutAttributeSchema).safeParse(raw);
+    const result = z17.array(RawMapsAboutAttributeSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] about parse failed", result.error.flatten());
       return [];
@@ -12384,7 +12749,7 @@ function mapsErrorResponse(c, err, errorCode) {
     attempts: rotationError?.attempts ?? void 0
   }, retryable ? 503 : 500);
 }
-var mapsApp = new Hono7();
+var mapsApp = new Hono8();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -12522,12 +12887,12 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/directory-routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join6 } from "path";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -12688,24 +13053,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z17.object({
-  query: z17.string().min(1),
-  state: z17.string().min(2).default("TN"),
-  minPopulation: z17.number().int().min(0).default(1e5),
-  populationYear: z17.union(POPULATION_YEARS.map((year) => z17.literal(year))).default(2025),
-  maxCities: z17.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z17.number().int().min(1).max(50).default(50),
-  concurrency: z17.number().int().min(1).max(5).default(5),
-  includeZipGroups: z17.boolean().default(true),
-  usZipsCsvPath: z17.string().optional(),
-  saveCsv: z17.boolean().default(true),
-  gl: z17.string().length(2).default("us"),
-  hl: z17.string().length(2).default("en"),
-  proxyMode: z17.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z17.string().regex(/^\d{5}$/).optional(),
-  debug: z17.boolean().default(false),
-  headless: z17.boolean().default(true),
-  kernelApiKey: z17.string().optional()
+var DirectoryWorkflowOptionsSchema = z18.object({
+  query: z18.string().min(1),
+  state: z18.string().min(2).default("TN"),
+  minPopulation: z18.number().int().min(0).default(1e5),
+  populationYear: z18.union(POPULATION_YEARS.map((year) => z18.literal(year))).default(2025),
+  maxCities: z18.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z18.number().int().min(1).max(50).default(50),
+  concurrency: z18.number().int().min(1).max(5).default(5),
+  includeZipGroups: z18.boolean().default(true),
+  usZipsCsvPath: z18.string().optional(),
+  saveCsv: z18.boolean().default(true),
+  gl: z18.string().length(2).default("us"),
+  hl: z18.string().length(2).default("en"),
+  proxyMode: z18.enum(["location", "configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z18.string().regex(/^\d{5}$/).optional(),
+  debug: z18.boolean().default(false),
+  headless: z18.boolean().default(true),
+  kernelApiKey: z18.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -12926,7 +13291,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono8();
+var directoryApp = new Hono9();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -12999,35 +13364,35 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 // src/api/workflow-routes.ts
 import { createHmac } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono9 } from "hono";
-import { z as z18 } from "zod";
-var workflowApp = new Hono9();
-var WorkflowInputSchema = z18.record(z18.unknown()).default({});
-var WorkflowIdSchema = z18.string().min(1);
-var CadenceSchema = z18.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z18.enum(["active", "paused"]);
-var RunBodySchema = z18.object({
+import { Hono as Hono10 } from "hono";
+import { z as z19 } from "zod";
+var workflowApp = new Hono10();
+var WorkflowInputSchema = z19.record(z19.unknown()).default({});
+var WorkflowIdSchema = z19.string().min(1);
+var CadenceSchema = z19.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z19.enum(["active", "paused"]);
+var RunBodySchema = z19.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z18.string().url().optional()
+  webhookUrl: z19.string().url().optional()
 });
-var ScheduleCreateSchema = z18.object({
+var ScheduleCreateSchema = z19.object({
   workflowId: WorkflowIdSchema,
-  name: z18.string().min(1).max(120).optional(),
+  name: z19.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z18.string().min(1).max(64).default("UTC"),
-  webhookUrl: z18.string().url().optional(),
-  nextRunAt: z18.string().datetime().optional()
+  timezone: z19.string().min(1).max(64).default("UTC"),
+  webhookUrl: z19.string().url().optional(),
+  nextRunAt: z19.string().datetime().optional()
 });
-var SchedulePatchSchema = z18.object({
-  name: z18.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z19.object({
+  name: z19.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z18.string().min(1).max(64).optional(),
-  webhookUrl: z18.string().url().nullable().optional(),
-  nextRunAt: z18.string().datetime().nullable().optional()
+  timezone: z19.string().min(1).max(64).optional(),
+  webhookUrl: z19.string().url().nullable().optional(),
+  nextRunAt: z19.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -13531,7 +13896,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash as createHash2 } from "crypto";
@@ -13843,7 +14208,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -13905,171 +14270,171 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z19.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z19.object({
-  query: z19.string().trim().min(1, "query is required"),
-  location: z19.string().trim().min(1).optional(),
-  gl: z19.string().trim().length(2).default("us"),
-  hl: z19.string().trim().length(2).default("en"),
-  device: z19.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z19.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z19.string().regex(/^\d{5}$/).optional(),
-  pages: z19.number().int().min(1).max(2).default(1),
-  debug: z19.boolean().default(false),
-  includePageSnapshots: z19.boolean().default(false),
-  pageSnapshotLimit: z19.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z20.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z20.object({
+  query: z20.string().trim().min(1, "query is required"),
+  location: z20.string().trim().min(1).optional(),
+  gl: z20.string().trim().length(2).default("us"),
+  hl: z20.string().trim().length(2).default("en"),
+  device: z20.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z20.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z20.string().regex(/^\d{5}$/).optional(),
+  pages: z20.number().int().min(1).max(2).default(1),
+  debug: z20.boolean().default(false),
+  includePageSnapshots: z20.boolean().default(false),
+  pageSnapshotLimit: z20.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z19.object({
+var SerpIntelligencePageSnapshotRequestSchema = z20.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z19.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z19.number().int().min(1).optional()
+  sourceKind: z20.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z20.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z19.object({
-  urls: z19.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
-  targets: z19.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z19.number().int().min(1).max(5).default(2),
-  timeoutMs: z19.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z19.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z20.object({
+  urls: z20.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  targets: z20.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z20.number().int().min(1).max(5).default(2),
+  timeoutMs: z20.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z20.boolean().default(false)
 }).strict();
-var SerpIntelligenceAICitationSchema = z19.object({
-  text: z19.string(),
-  href: z19.string()
+var SerpIntelligenceAICitationSchema = z20.object({
+  text: z20.string(),
+  href: z20.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z19.object({
-  position: z19.number().int().min(1),
-  title: z19.string(),
-  url: z19.string(),
-  domain: z19.string(),
-  cite: z19.string().nullable(),
-  snippet: z19.string().nullable(),
-  isRedditStyle: z19.boolean(),
-  inlineRating: z19.object({
-    value: z19.string(),
-    count: z19.string()
+var SerpIntelligenceOrganicResultSchema = z20.object({
+  position: z20.number().int().min(1),
+  title: z20.string(),
+  url: z20.string(),
+  domain: z20.string(),
+  cite: z20.string().nullable(),
+  snippet: z20.string().nullable(),
+  isRedditStyle: z20.boolean(),
+  inlineRating: z20.object({
+    value: z20.string(),
+    count: z20.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z19.object({
-  status: z19.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z19.object({
-    city: z19.string(),
-    regionCode: z19.string().nullable(),
-    canonicalLocation: z19.string()
+var SerpIntelligenceLocationEvidenceSchema = z20.object({
+  status: z20.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z20.object({
+    city: z20.string(),
+    regionCode: z20.string().nullable(),
+    canonicalLocation: z20.string()
   }).strict().nullable(),
-  candidates: z19.array(z19.object({
-    city: z19.string(),
-    regionCode: z19.string(),
-    count: z19.number().int().min(0),
-    examples: z19.array(z19.string())
+  candidates: z20.array(z20.object({
+    city: z20.string(),
+    regionCode: z20.string(),
+    count: z20.number().int().min(0),
+    examples: z20.array(z20.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z19.object({
-  seed: z19.string(),
-  location: z19.string().nullable(),
-  extractedAt: z19.string(),
-  totalQuestions: z19.number().int().min(0),
-  surface: z19.enum(["web", "aim", "unknown"]),
-  aiOverview: z19.object({
-    detected: z19.boolean(),
-    text: z19.string().nullable(),
-    citations: z19.array(SerpIntelligenceAICitationSchema),
-    expanded: z19.boolean().optional(),
-    fullyExpanded: z19.boolean().optional(),
-    sections: z19.array(z19.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z20.object({
+  seed: z20.string(),
+  location: z20.string().nullable(),
+  extractedAt: z20.string(),
+  totalQuestions: z20.number().int().min(0),
+  surface: z20.enum(["web", "aim", "unknown"]),
+  aiOverview: z20.object({
+    detected: z20.boolean(),
+    text: z20.string().nullable(),
+    citations: z20.array(SerpIntelligenceAICitationSchema),
+    expanded: z20.boolean().optional(),
+    fullyExpanded: z20.boolean().optional(),
+    sections: z20.array(z20.string()).optional()
   }).strict(),
-  aiMode: z19.object({
-    detected: z19.boolean(),
-    text: z19.string().nullable(),
-    citations: z19.array(SerpIntelligenceAICitationSchema)
+  aiMode: z20.object({
+    detected: z20.boolean(),
+    text: z20.string().nullable(),
+    citations: z20.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z19.array(z19.unknown()),
-  flat: z19.array(z19.unknown()),
-  videos: z19.array(z19.unknown()),
-  forums: z19.array(z19.unknown()),
-  organicResults: z19.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z19.array(z19.unknown()),
-  entityIds: z19.object({
-    entities: z19.array(z19.object({
-      name: z19.string(),
-      kgId: z19.string().nullable(),
-      cid: z19.string().nullable(),
-      gcid: z19.string().nullable()
+  tree: z20.array(z20.unknown()),
+  flat: z20.array(z20.unknown()),
+  videos: z20.array(z20.unknown()),
+  forums: z20.array(z20.unknown()),
+  organicResults: z20.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z20.array(z20.unknown()),
+  entityIds: z20.object({
+    entities: z20.array(z20.object({
+      name: z20.string(),
+      kgId: z20.string().nullable(),
+      cid: z20.string().nullable(),
+      gcid: z20.string().nullable()
     }).strict()),
-    kgIds: z19.array(z19.string()),
-    cids: z19.array(z19.string()),
-    gcids: z19.array(z19.string())
+    kgIds: z20.array(z20.string()),
+    cids: z20.array(z20.string()),
+    gcids: z20.array(z20.string())
   }).strict(),
-  stats: z19.object({
-    seed: z19.string(),
-    totalQuestions: z19.number().int().min(0),
-    maxDepthReached: z19.number().int().min(0),
-    durationMs: z19.number().min(0),
-    errorCount: z19.number().int().min(0)
+  stats: z20.object({
+    seed: z20.string(),
+    totalQuestions: z20.number().int().min(0),
+    maxDepthReached: z20.number().int().min(0),
+    durationMs: z20.number().min(0),
+    errorCount: z20.number().int().min(0)
   }).strict(),
-  diagnostics: z19.object({
-    completionStatus: z19.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z19.null(),
-    warnings: z19.array(z19.unknown()).optional(),
-    debug: z19.object({
+  diagnostics: z20.object({
+    completionStatus: z20.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z20.null(),
+    warnings: z20.array(z20.unknown()).optional(),
+    debug: z20.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z19.array(z19.unknown())
+  whatPeopleSaying: z20.array(z20.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z19.object({
-  attemptNumber: z19.number().int().min(1),
-  outcome: z19.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z19.string().optional(),
-  completedAt: z19.string().optional(),
-  durationMs: z19.number().min(0).optional(),
-  problemCode: z19.string().optional(),
-  message: z19.string().optional(),
-  kernelSessionId: z19.string().nullable().optional(),
-  cleanupSucceeded: z19.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z20.object({
+  attemptNumber: z20.number().int().min(1),
+  outcome: z20.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z20.string().optional(),
+  completedAt: z20.string().optional(),
+  durationMs: z20.number().min(0).optional(),
+  problemCode: z20.string().optional(),
+  message: z20.string().optional(),
+  kernelSessionId: z20.string().nullable().optional(),
+  cleanupSucceeded: z20.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z19.object({
+var SerpPageSnapshotCaptureSchema = z20.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z19.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z19.number().int().min(1).nullable(),
-  status: z19.enum(SerpPageFetchStatusValues),
-  fetchedVia: z19.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z19.number().int().min(100).max(599).nullable(),
-  contentType: z19.string().nullable(),
-  title: z19.string().nullable(),
+  sourceKind: z20.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z20.number().int().min(1).nullable(),
+  status: z20.enum(SerpPageFetchStatusValues),
+  fetchedVia: z20.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z20.number().int().min(100).max(599).nullable(),
+  contentType: z20.string().nullable(),
+  title: z20.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z19.string().nullable(),
-  headings: z19.array(z19.object({
-    level: z19.number().int().min(1).max(6),
-    text: z19.string()
+  metaDescription: z20.string().nullable(),
+  headings: z20.array(z20.object({
+    level: z20.number().int().min(1).max(6),
+    text: z20.string()
   }).strict()).default([]),
-  artifact: z19.object({
-    htmlBlobUrl: z19.string().url().nullable(),
-    textBlobUrl: z19.string().url().nullable(),
-    markdownBlobUrl: z19.string().url().nullable(),
-    screenshotBlobUrl: z19.string().url().nullable(),
-    contentSha256: z19.string().nullable(),
-    capturedAt: z19.string().nullable()
+  artifact: z20.object({
+    htmlBlobUrl: z20.string().url().nullable(),
+    textBlobUrl: z20.string().url().nullable(),
+    markdownBlobUrl: z20.string().url().nullable(),
+    screenshotBlobUrl: z20.string().url().nullable(),
+    contentSha256: z20.string().nullable(),
+    capturedAt: z20.string().nullable()
   }).strict(),
-  error: z19.object({
-    code: z19.string(),
-    message: z19.string()
+  error: z20.object({
+    code: z20.string(),
+    message: z20.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z19.object({
+var SerpIntelligenceCaptureResponseSchema = z20.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z19.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z20.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z19.array(SerpPageSnapshotCaptureSchema),
-  billing: z19.object({
-    creditsUsed: z19.number().min(0).optional(),
-    requestId: z19.string().optional(),
-    jobId: z19.string().optional()
+  pageSnapshotArtifacts: z20.array(SerpPageSnapshotCaptureSchema),
+  billing: z20.object({
+    creditsUsed: z20.number().min(0).optional(),
+    requestId: z20.string().optional(),
+    jobId: z20.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z19.object({
-  pageSnapshotArtifacts: z19.array(SerpPageSnapshotCaptureSchema),
-  attempts: z19.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z20.object({
+  pageSnapshotArtifacts: z20.array(SerpPageSnapshotCaptureSchema),
+  attempts: z20.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -14241,7 +14606,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 Hono10();
+var serpIntelligenceApp = new Hono11();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -14410,7 +14775,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 // src/mcp/mcp-oauth.ts
@@ -14494,7 +14859,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return callerKey;
 }
-var mcpApp = new Hono11();
+var mcpApp = new Hono12();
 mcpApp.all("/", async (c) => {
   try {
     const keyOrError = await requireMcpCallerKey(c);
@@ -14518,7 +14883,7 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono13 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -15952,7 +16317,7 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono12();
+  const app2 = new Hono13();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
@@ -16658,7 +17023,7 @@ if (state.key) { refreshSessions(); if (state.current) selectSession(state.curre
 
 // src/api/stripe-routes.ts
 import Stripe from "stripe";
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono14 } from "hono";
 
 // src/api/memory.ts
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
@@ -16797,10 +17162,22 @@ async function syncMemoryKeyPlan(user, plan) {
   const res = await memoryCall("setScopeTool", { keyId: target.keyId, plan: effectivePlan }, key);
   return { ok: res.ok, error: res.error };
 }
+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", {
+    granteeIdentity: identity,
+    enabled,
+    quotaPerPeriod,
+    mcpScraperApiKey: user.api_key
+  }, admin);
+  return { ok: res.ok, error: res.error };
+}
 
 // src/api/stripe-routes.ts
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono13();
+var stripeApp = new Hono14();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -16839,6 +17216,15 @@ stripeApp.post("/webhooks", async (c) => {
       }
       return c.json({ received: true });
     }
+    if (priceId && priceId in SCHEDULING_PLANS) {
+      const sched = SCHEDULING_PLANS[priceId];
+      const user2 = await resolveUser(sub.customer, sub.customer_email);
+      if (user2) {
+        const live = sub.status === "active" || sub.status === "trialing";
+        await syncScheduleEntitlement(user2, live, sched.quota_per_period);
+      }
+      return c.json({ received: true });
+    }
     const user = await getUserByStripeCustomerId(sub.customer);
     if (!user) return c.json({ received: true });
     if (priceId && priceId in SUBSCRIPTION_TIERS) {
@@ -16861,6 +17247,11 @@ stripeApp.post("/webhooks", async (c) => {
       }
       return c.json({ received: true });
     }
+    if (priceId && priceId in SCHEDULING_PLANS) {
+      const user2 = await getUserByStripeCustomerId(sub.customer);
+      if (user2) await syncScheduleEntitlement(user2, false);
+      return c.json({ received: true });
+    }
     const user = await getUserByStripeCustomerId(sub.customer);
     if (!user) return c.json({ received: true });
     if (priceId && priceId in SUBSCRIPTION_TIERS) {
@@ -16886,7 +17277,7 @@ async function resolveUser(customerId, emailFallback) {
 }
 
 // src/api/oauth-routes.ts
-import { Hono as Hono14 } from "hono";
+import { Hono as Hono15 } 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";
@@ -16934,10 +17325,14 @@ function isAllowedRedirect(uri) {
   } catch {
     return false;
   }
-  if (u.protocol !== "https:") return false;
   const h = u.hostname.toLowerCase();
+  if (u.protocol === "http:" && (h === "localhost" || h === "127.0.0.1" || h === "::1")) return true;
+  if (u.protocol !== "https:") return false;
   if (["claude.ai", "www.claude.ai", "claude.com", "www.claude.com"].includes(h)) return true;
   if (h.endsWith(".claude.ai") || h.endsWith(".claude.com")) return true;
+  if (["chatgpt.com", "www.chatgpt.com", "chat.openai.com", "www.chat.openai.com"].includes(h)) return true;
+  if (h.endsWith(".chatgpt.com") || h.endsWith(".openai.com")) return true;
+  if (h === "viktor.com" || h.endsWith(".viktor.com")) return true;
   const extra = (process.env.OAUTH_EXTRA_REDIRECT_HOSTS ?? "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
   return extra.includes(h);
 }
@@ -17050,7 +17445,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 Hono14();
+var oauthApp = new Hono15();
 oauthApp.use("*", async (c, next) => {
   c.header("Access-Control-Allow-Origin", "*");
   c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -17297,8 +17692,8 @@ oauthApp.post("/oauth/token", async (c) => {
 });
 
 // src/api/chat-routes.ts
-import { Hono as Hono15 } from "hono";
-var chatApp = new Hono15();
+import { Hono as Hono16 } from "hono";
+var chatApp = new Hono16();
 function tokenOk(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -17967,6 +18362,331 @@ loadChannels();
 </html>`;
 }
 
+// src/api/schedule-routes.ts
+import { Hono as Hono17 } from "hono";
+var scheduleApp = new Hono17();
+function tokenOk2(token) {
+  return !!token && token.startsWith("mk_") && token.length > 10;
+}
+function jsonError2(message, status = 400) {
+  return new Response(JSON.stringify({ ok: false, error: message }), { status, headers: { "content-type": "application/json" } });
+}
+scheduleApp.get("/api/status", async (c) => {
+  const token = c.req.query("token");
+  if (!tokenOk2(token)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("getScheduleStatusTool", {}, token);
+  return c.json(r);
+});
+scheduleApp.get("/api/vaults", async (c) => {
+  const token = c.req.query("token");
+  if (!tokenOk2(token)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("listVaultsTool", {}, token);
+  if (!r.ok) return c.json(r);
+  const vaults = (r.vaults ?? []).filter((v) => v.kind !== "channel");
+  return c.json({ ok: true, vaults });
+});
+scheduleApp.get("/api/actions", async (c) => {
+  const token = c.req.query("token");
+  if (!tokenOk2(token)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("listScheduledActionsTool", {}, token);
+  return c.json(r);
+});
+scheduleApp.post("/api/propose", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (!tokenOk2(body.token)) return jsonError2("missing or malformed token", 401);
+  if (!body.request) return jsonError2("request is required");
+  const r = await memoryCall("proposeScheduledActionTool", { request: body.request }, body.token);
+  return c.json(r);
+});
+scheduleApp.post("/api/actions", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (!tokenOk2(body.token)) return jsonError2("missing or malformed token", 401);
+  if (!body.description || !body.vault || !body.cadence) return jsonError2("description, vault and cadence are required");
+  const r = await memoryCall("createScheduledActionTool", { description: body.description, vault: body.vault, cadence: body.cadence }, body.token);
+  return c.json(r);
+});
+scheduleApp.post("/api/actions/:id/pause", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (!tokenOk2(body.token)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("pauseScheduledActionTool", { id: c.req.param("id") }, body.token);
+  return c.json(r);
+});
+scheduleApp.post("/api/actions/:id/resume", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (!tokenOk2(body.token)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("resumeScheduledActionTool", { id: c.req.param("id") }, body.token);
+  return c.json(r);
+});
+scheduleApp.post("/api/actions/:id/delete", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (!tokenOk2(body.token)) return jsonError2("missing or malformed token", 401);
+  const r = await memoryCall("deleteScheduledActionTool", { id: c.req.param("id") }, body.token);
+  return c.json(r);
+});
+scheduleApp.get("/:token", (c) => {
+  const token = c.req.param("token");
+  if (!tokenOk2(token)) {
+    return c.html(`<!doctype html><html><body style="font-family:system-ui;padding:40px;color:#3D3548"><h2>This automations link isn't valid.</h2><p>Ask the AI to run get-schedule-link again, or revoke-schedule-link then get-schedule-link if you think it was compromised.</p></body></html>`, 401);
+  }
+  return c.html(renderSchedulePage(token));
+});
+function renderSchedulePage(token) {
+  return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+<title>Scheduled Actions</title>
+<style>
+  :root { color-scheme: light; --accent: #d06045; --warn: #b3261e; --bg: #faf8f6; --card: #fff; --line: #e8e1db; --ink: #211a14; --muted: #7a6f64; } html, body, div, span { box-sizing: border-box; -webkit-tap-highlight-color: transparent; }
+  body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif; color: var(--ink); background: var(--bg); padding-bottom: 90px; }
+  header { position: sticky; top: 0; background: var(--bg); padding: 18px 16px 12px; border-bottom: 1px solid var(--line); z-index: 10; }
+  h1 { font-size: 21px; font-weight: 800; margin: 0 0 4px; letter-spacing: -.01em; }
+  .quota { font-size: 13px; color: var(--muted); transition: color .2s; }
+  .quota.warn { color: var(--warn); font-weight: 600; }
+  .quota-bar { height: 6px; border-radius: 999px; background: var(--line); margin-top: 6px; overflow: hidden; }
+  .quota-bar-fill { height: 100%; background: var(--accent); transition: width .3s ease, background .2s; }
+  .quota-bar-fill.warn { background: var(--warn); }
+  main { padding: 14px; max-width: 640px; margin: 0 auto; }
+  .card { background: var(--card); border: 1px solid var(--line); border-radius: 14px; padding: 16px; margin-bottom: 12px; animation: rise .25s ease both; }
+  @keyframes rise { from { opacity: 0; transform: translateY(6px); } to { opacity: 1; transform: translateY(0); } }
+  .empty { text-align: center; color: var(--muted); padding: 56px 20px; font-size: 14px; }
+  .empty-icon { font-size: 32px; margin-bottom: 10px; opacity: .7; }
+  .action-desc { font-size: 15px; line-height: 1.45; margin-bottom: 6px; }
+  .action-meta { font-size: 12.5px; color: var(--muted); display: flex; flex-wrap: wrap; gap: 6px 10px; }
+  .pill { display: inline-block; padding: 2px 8px; border-radius: 999px; font-size: 11.5px; font-weight: 600; }
+  .pill-active { background: #e3f3ea; color: #1a7a4c; }
+  .pill-paused { background: #f3ecd8; color: #93701a; }
+  .action-row { display: flex; gap: 8px; margin-top: 12px; }
+  button { font: inherit; }
+  .btn { flex: 1; padding: 10px 12px; border-radius: 9px; border: 1px solid var(--line); background: #fff; color: var(--ink); font-size: 13.5px; font-weight: 600; cursor: pointer; transition: transform .08s ease, background .15s, color .15s, border-color .15s; }
+  .btn:active { transform: scale(.96); }
+  .btn-accent { background: var(--accent); border-color: var(--accent); color: #fff; }
+  .btn-danger { color: #b3261e; }
+  .btn-danger.confirming { background: var(--warn); border-color: var(--warn); color: #fff; }
+  .fab { position: fixed; bottom: 20px; left: 16px; right: 16px; max-width: 608px; margin: 0 auto; background: var(--accent); color: #fff; border: none; border-radius: 14px; padding: 16px; font-size: 15.5px; font-weight: 700; cursor: pointer; box-shadow: 0 8px 24px rgba(208,96,69,.35); transition: transform .1s ease, box-shadow .15s; }
+  .fab:active { transform: scale(.98); box-shadow: 0 4px 14px rgba(208,96,69,.35); }
+  .overlay { position: fixed; inset: 0; background: rgba(33,26,20,.45); display: flex; align-items: flex-end; justify-content: center; z-index: 50; opacity: 0; pointer-events: none; transition: opacity .2s ease; }
+  .overlay.open { opacity: 1; pointer-events: auto; }
+  .sheet { width: 100%; max-width: 640px; background: #fff; border-radius: 18px 18px 0 0; max-height: 88vh; overflow: auto; padding: 18px 16px 24px; transform: translateY(28px); transition: transform .28s cubic-bezier(.16,1,.3,1); }
+  .overlay.open .sheet { transform: translateY(0); }
+  .sheet h2 { font-size: 17px; margin: 0 0 14px; }
+  textarea, input, select { width: 100%; box-sizing: border-box; border: 1px solid var(--line); border-radius: 10px; padding: 12px 13px; font-size: 15px; outline: none; margin-top: 6px; font-family: inherit; transition: border-color .15s; }
+  textarea:focus, input:focus, select:focus { border-color: var(--accent); }
+  textarea.autogrow { resize: none; overflow: hidden; line-height: 1.5; min-height: 90px; transition: height .12s ease; }
+  label { font-size: 12.5px; font-weight: 700; color: var(--muted); text-transform: uppercase; letter-spacing: .03em; display: block; margin-top: 14px; }
+  .rationale { font-size: 13px; color: var(--muted); background: #f5f0ea; border-radius: 9px; padding: 10px 12px; margin-top: 10px; }
+  .sheet-actions { display: flex; gap: 8px; margin-top: 18px; }
+  .err { color: #b3261e; font-size: 13px; margin-top: 8px; display: none; }
+  .spin { opacity: .55; pointer-events: none; }
+  .toast { position: fixed; bottom: 96px; left: 50%; background: var(--ink); color: #fff; padding: 10px 18px; border-radius: 999px; font-size: 13.5px; font-weight: 600; z-index: 60; opacity: 0; pointer-events: none; transform: translate(-50%, 8px); transition: opacity .2s ease, transform .2s ease; }
+  .toast.show { opacity: 1; transform: translate(-50%, 0); }
+</style>
+</head>
+<body>
+<header>
+  <h1>Scheduled Actions</h1>
+  <div class="quota" id="quota-text">Loading\u2026</div>
+  <div class="quota-bar"><div class="quota-bar-fill" id="quota-fill" style="width:0%"></div></div>
+</header>
+<main id="list"></main>
+<button class="fab" id="new-btn">+ New scheduled action</button>
+<div class="toast" id="toast"></div>
+
+<div class="overlay" id="propose-overlay">
+  <div class="sheet">
+    <h2>What should this do?</h2>
+    <textarea id="propose-input" class="autogrow" rows="3" placeholder="e.g. check my competitor's pricing page every Monday and summarize what changed"></textarea>
+    <div class="err" id="propose-err"></div>
+    <div class="sheet-actions">
+      <button class="btn" id="propose-cancel">Cancel</button>
+      <button class="btn btn-accent" id="propose-submit">Propose</button>
+    </div>
+  </div>
+</div>
+
+<div class="overlay" id="confirm-overlay">
+  <div class="sheet">
+    <h2>Review before confirming</h2>
+    <label>Description</label>
+    <textarea id="confirm-description" class="autogrow" rows="8"></textarea>
+    <label>Vault</label>
+    <select id="confirm-vault"></select>
+    <label>Cadence</label>
+    <select id="confirm-cadence">
+      <option value="daily">Daily</option>
+      <option value="weekly">Weekly</option>
+      <option value="monthly">Monthly</option>
+    </select>
+    <div class="rationale" id="confirm-rationale"></div>
+    <div class="err" id="confirm-err"></div>
+    <div class="sheet-actions">
+      <button class="btn" id="confirm-cancel">Cancel</button>
+      <button class="btn btn-accent" id="confirm-submit">Confirm & create</button>
+    </div>
+  </div>
+</div>
+
+<script>
+const TOKEN = ${JSON.stringify(token)};
+const state = { actions: [], vaults: [] };
+
+function api(path, opts) { return fetch('/schedule' + path, opts).then(r => r.json()); }
+function get(path, params) { const qs = new URLSearchParams({ token: TOKEN, ...(params||{}) }).toString(); return api(path + '?' + qs); }
+function post(path, body) { return api(path, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ token: TOKEN, ...(body||{}) }) }); }
+function esc(s) { return (s || '').replace(/[&<>]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c])); }
+function fmt(iso) { try { return new Date(iso).toLocaleString([], { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' }); } catch (e) { return iso || ''; } }
+
+function autogrow(el) { el.style.height = 'auto'; el.style.height = el.scrollHeight + 'px'; }
+document.querySelectorAll('.autogrow').forEach(el => {
+  el.addEventListener('input', () => autogrow(el));
+});
+
+let toastTimer = null;
+function toast(message) {
+  const el = document.getElementById('toast');
+  el.textContent = message;
+  el.classList.add('show');
+  if (toastTimer) clearTimeout(toastTimer);
+  toastTimer = setTimeout(() => el.classList.remove('show'), 2200);
+}
+
+async function loadStatus() {
+  const r = await get('/api/status');
+  const text = document.getElementById('quota-text');
+  const fill = document.getElementById('quota-fill');
+  if (!r.ok || !r.enabled) {
+    text.textContent = 'No active Scheduled Actions subscription.';
+    text.classList.remove('warn');
+    fill.style.width = '0%';
+    fill.classList.remove('warn');
+    return;
+  }
+  const pct = Math.min(100, Math.round((r.usedThisPeriod / Math.max(1, r.quotaPerPeriod)) * 100));
+  const nearLimit = pct >= 90;
+  text.textContent = r.usedThisPeriod + ' / ' + r.quotaPerPeriod + ' actions used this period' + (nearLimit ? ' \u2014 almost at your limit' : '');
+  text.classList.toggle('warn', nearLimit);
+  fill.style.width = pct + '%';
+  fill.classList.toggle('warn', nearLimit);
+}
+
+async function loadVaults() {
+  const r = await get('/api/vaults');
+  state.vaults = r.ok ? (r.vaults || []) : [];
+  const sel = document.getElementById('confirm-vault');
+  sel.innerHTML = state.vaults.map(v => '<option value="' + esc(v.handle) + '">' + esc(v.handle) + '</option>').join('');
+}
+
+async function loadActions() {
+  const r = await get('/api/actions');
+  const box = document.getElementById('list');
+  if (!r.ok) { box.innerHTML = '<div class="empty">' + esc(r.error || 'Could not load') + '</div>'; return; }
+  state.actions = r.actions || [];
+  if (!state.actions.length) {
+    box.innerHTML = '<div class="empty"><div class="empty-icon">\u23F1\uFE0F</div>No scheduled actions yet.<br>Tap "New scheduled action" to create your first one.</div>';
+    return;
+  }
+  box.innerHTML = state.actions.map(renderAction).join('');
+  state.actions.forEach(a => {
+    const pauseBtn = document.getElementById('pause-' + a.id);
+    const resumeBtn = document.getElementById('resume-' + a.id);
+    const delBtn = document.getElementById('delete-' + a.id);
+    if (pauseBtn) pauseBtn.onclick = () => act('pause', a.id, 'Paused');
+    if (resumeBtn) resumeBtn.onclick = () => act('resume', a.id, 'Resumed');
+    if (delBtn) delBtn.onclick = () => confirmDelete(delBtn, a.id);
+  });
+}
+
+function confirmDelete(btn, id) {
+  if (!btn.classList.contains('confirming')) {
+    btn.classList.add('confirming');
+    btn.textContent = 'Tap again to delete';
+    btn.dataset.confirmTimer = setTimeout(() => {
+      btn.classList.remove('confirming');
+      btn.textContent = 'Delete';
+    }, 3000);
+    return;
+  }
+  clearTimeout(btn.dataset.confirmTimer);
+  act('delete', id, 'Deleted');
+}
+
+function renderAction(a) {
+  const pill = a.status === 'active' ? '<span class="pill pill-active">active</span>' : '<span class="pill pill-paused">' + esc(a.status) + '</span>';
+  return '<div class="card">' +
+    '<div class="action-desc">' + esc(a.description) + '</div>' +
+    '<div class="action-meta">' + pill + '<span>' + esc(a.cadence) + '</span><span>next ' + fmt(a.nextRunAt) + '</span>' +
+    (a.lastRunStatus ? '<span>last: ' + esc(a.lastRunStatus) + '</span>' : '') + '</div>' +
+    '<div class="action-row">' +
+    (a.status === 'active'
+      ? '<button class="btn" id="pause-' + a.id + '">Pause</button>'
+      : '<button class="btn" id="resume-' + a.id + '">Resume</button>') +
+    '<button class="btn btn-danger" id="delete-' + a.id + '">Delete</button>' +
+    '</div></div>';
+}
+
+async function act(kind, id, toastMessage) {
+  await post('/api/actions/' + id + '/' + kind, {});
+  await loadActions();
+  await loadStatus();
+  if (toastMessage) toast(toastMessage);
+}
+
+document.getElementById('new-btn').onclick = () => {
+  document.getElementById('propose-input').value = '';
+  document.getElementById('propose-err').style.display = 'none';
+  document.getElementById('propose-overlay').classList.add('open');
+};
+document.getElementById('propose-cancel').onclick = () => document.getElementById('propose-overlay').classList.remove('open');
+
+document.getElementById('propose-submit').onclick = async () => {
+  const request = document.getElementById('propose-input').value.trim();
+  const errEl = document.getElementById('propose-err');
+  errEl.style.display = 'none';
+  if (!request) return;
+  const btn = document.getElementById('propose-submit');
+  btn.classList.add('spin'); btn.textContent = 'Thinking\u2026';
+  const r = await post('/api/propose', { request });
+  btn.classList.remove('spin'); btn.textContent = 'Propose';
+  if (!r.ok) { errEl.textContent = r.error || 'Could not interpret that request'; errEl.style.display = 'block'; return; }
+  document.getElementById('propose-overlay').classList.remove('open');
+  document.getElementById('confirm-description').value = r.description || '';
+  document.getElementById('confirm-vault').value = r.vault || '';
+  document.getElementById('confirm-cadence').value = r.cadence || 'daily';
+  document.getElementById('confirm-rationale').textContent = r.rationale || '';
+  document.getElementById('confirm-err').style.display = 'none';
+  document.getElementById('confirm-overlay').classList.add('open');
+  autogrow(document.getElementById('confirm-description'));
+};
+
+document.getElementById('confirm-cancel').onclick = () => document.getElementById('confirm-overlay').classList.remove('open');
+
+document.getElementById('confirm-submit').onclick = async () => {
+  const description = document.getElementById('confirm-description').value.trim();
+  const vault = document.getElementById('confirm-vault').value;
+  const cadence = document.getElementById('confirm-cadence').value;
+  const errEl = document.getElementById('confirm-err');
+  errEl.style.display = 'none';
+  if (!description || !vault) { errEl.textContent = 'Description and vault are required'; errEl.style.display = 'block'; return; }
+  const btn = document.getElementById('confirm-submit');
+  btn.classList.add('spin'); btn.textContent = 'Creating\u2026';
+  const r = await post('/api/actions', { description, vault, cadence });
+  btn.classList.remove('spin'); btn.textContent = 'Confirm & create';
+  if (!r.ok) { errEl.textContent = r.error || 'Could not create scheduled action'; errEl.style.display = 'block'; return; }
+  document.getElementById('confirm-overlay').classList.remove('open');
+  await loadActions();
+  await loadStatus();
+  toast('Scheduled action created');
+};
+
+loadStatus();
+loadVaults();
+loadActions();
+</script>
+</body>
+</html>`;
+}
+
 // src/api/site-audit-worker.ts
 var MAX_CONCURRENT_SITE_AUDIT = 1;
 async function drainSiteAuditQueue(budget) {
@@ -18172,16 +18892,32 @@ function toGb(bytes) {
 }
 async function entitledVaultRows(identity) {
   const rows = await sql().query(
-    `SELECT vault, owner_identity FROM mem_vault_registry WHERE grantee = $1 ORDER BY created_at ASC`,
+    `SELECT vault, owner_identity, contract FROM mem_vault_registry WHERE grantee = $1 ORDER BY created_at ASC`,
     [identity]
   );
   const seen = /* @__PURE__ */ new Map();
   for (const r of rows) {
     if (seen.has(r.vault)) continue;
-    seen.set(r.vault, { vault: r.vault, owner: r.owner_identity, physical: physicalVault(r.owner_identity, r.vault) });
+    const kind = r.contract?.kind === "channel" ? "channel" : "notes";
+    seen.set(r.vault, { vault: r.vault, owner: r.owner_identity, physical: physicalVault(r.owner_identity, r.vault), kind });
   }
   return [...seen.values()];
 }
+var EMBED_BYTES_PER_CHUNK = Number(process.env.JINA_EMBED_DIM ?? 1024) * 4;
+async function embedBytesByPhysical(physicals) {
+  const m = /* @__PURE__ */ new Map();
+  try {
+    const rows = await sql().query(
+      `SELECT metadata->>'vault' AS vault, COUNT(*)::bigint AS chunks
+       FROM "memory" WHERE metadata->>'vault' = ANY($1) GROUP BY 1`,
+      [physicals]
+    );
+    for (const r of rows) if (r.vault) m.set(r.vault, Number(r.chunks) * EMBED_BYTES_PER_CHUNK);
+  } catch {
+    return m;
+  }
+  return m;
+}
 async function storageByPhysical(physicals) {
   if (physicals.length === 0) return /* @__PURE__ */ new Map();
   const rows = await sql().query(
@@ -18189,8 +18925,9 @@ async function storageByPhysical(physicals) {
      FROM mem_notes WHERE vault = ANY($1) GROUP BY vault`,
     [physicals]
   );
+  const embed = await embedBytesByPhysical(physicals);
   const m = /* @__PURE__ */ new Map();
-  for (const r of rows) m.set(r.vault, { notes: Number(r.notes), bytes: Number(r.bytes) });
+  for (const r of rows) m.set(r.vault, { notes: Number(r.notes), bytes: Number(r.bytes) + (embed.get(r.vault) ?? 0) });
   return m;
 }
 async function dbListVaults(identity) {
@@ -18204,7 +18941,8 @@ async function dbListVaults(identity) {
       role: isOwner ? "owner" : "shared",
       ...isOwner ? {} : { sharedBy: e.owner },
       notes: st?.notes ?? 0,
-      bytes: st?.bytes ?? 0
+      bytes: st?.bytes ?? 0,
+      kind: e.kind
     };
   });
 }
@@ -18381,7 +19119,7 @@ var sessionAuth = createMiddleware3(async (c, next) => {
   c.set("sessionUser", { ...refreshed, balance_mc: balanceMc });
   return next();
 });
-var app = new Hono16();
+var app = new Hono18();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -18572,6 +19310,7 @@ app.get("/me", async (c) => {
   const stats = await getUserStats(user.id);
   return c.json({
     authenticated: true,
+    id: user.id,
     email: user.email,
     api_key: user.key_active ? user.api_key : null,
     created_at: user.created_at,
@@ -18646,6 +19385,28 @@ app.get("/memory/vaults", auth2, async (c) => {
     return c.json({ ok: false, error: err instanceof Error ? err.message : "could not load vaults" }, 502);
   }
 });
+app.get("/memory/approved-senders", auth2, async (c) => {
+  const { key, error } = await getOrCreateUserMemoryKey(c.get("user"));
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 502);
+  const r = await memoryCall("listApprovedSendersTool", {}, key);
+  return c.json(r);
+});
+app.post("/memory/approved-senders", auth2, async (c) => {
+  const { key, error } = await getOrCreateUserMemoryKey(c.get("user"));
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 502);
+  const body = await c.req.json().catch(() => ({}));
+  const senderIdentity = body.senderIdentity?.trim();
+  if (!senderIdentity) return c.json({ ok: false, error: "senderIdentity is required" }, 400);
+  const r = await memoryCall("approveSenderTool", { senderIdentity }, key);
+  return c.json(r);
+});
+app.delete("/memory/approved-senders/:identity", auth2, async (c) => {
+  const { key, error } = await getOrCreateUserMemoryKey(c.get("user"));
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 502);
+  const senderIdentity = c.req.param("identity");
+  const r = await memoryCall("removeApprovedSenderTool", { senderIdentity }, key);
+  return c.json(r);
+});
 app.get("/memory/connect", auth2, async (c) => {
   const { key, error } = await getOrCreateUserMemoryKey(c.get("user"));
   if (!key) return c.json({ error: error ?? "memory unavailable" }, 502);
@@ -18809,6 +19570,154 @@ app.post("/memory/portal", auth2, async (c) => {
     return c.json({ error: message }, 500);
   }
 });
+app.post("/schedule-checkout", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const body = await c.req.json().catch(() => ({}));
+    const priceId = body.priceId?.trim();
+    if (!priceId || !SCHEDULING_PLANS[priceId]) return c.json({ error: "Invalid priceId \u2014 must be a scheduling plan price." }, 400);
+    const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
+    if (!secret2) return c.json({ error: "Stripe is not configured." }, 503);
+    const stripeClient = new Stripe2(secret2, { apiVersion: STRIPE_API_VERSION });
+    let customerId = user.stripe_customer_id;
+    if (!customerId) {
+      const customer = await stripeClient.customers.create({ email: user.email });
+      customerId = customer.id;
+      await setStripeCustomerId(user.id, customerId);
+    }
+    const session = await stripeClient.checkout.sessions.create({
+      mode: "subscription",
+      customer: customerId,
+      line_items: [{ price: priceId, quantity: 1 }],
+      client_reference_id: String(user.id),
+      metadata: { product: "mcp-scheduling", userId: String(user.id) },
+      subscription_data: { metadata: { product: "mcp-scheduling", userId: String(user.id) } },
+      automatic_tax: { enabled: true },
+      billing_address_collection: "required",
+      customer_update: { address: "auto", name: "auto" },
+      tax_id_collection: { enabled: true },
+      success_url: `${appOrigin()}/memory?billing=success`,
+      cancel_url: `${appOrigin()}/memory?billing=cancel`
+    });
+    if (!session.url) return c.json({ error: "Stripe did not return a checkout URL." }, 502);
+    return c.json({ url: session.url });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to start scheduling checkout.";
+    console.error("[schedule-checkout]", message);
+    return c.json({ error: message }, 500);
+  }
+});
+app.get("/schedule-status", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const { key, error } = await getOrCreateUserMemoryKey(user);
+    if (!key) return c.json({ error: error ?? "memory unavailable" }, 503);
+    const r = await memoryCall("getScheduleStatusTool", {}, key);
+    return c.json(r);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to get schedule status.";
+    console.error("[schedule-status]", message);
+    return c.json({ error: message }, 500);
+  }
+});
+app.post("/schedule-link", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const { key, error } = await getOrCreateUserMemoryKey(user);
+    if (!key) return c.json({ error: error ?? "memory unavailable" }, 503);
+    const r = await memoryCall("getScheduleLinkTool", {}, key);
+    return c.json(r);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to get schedule link.";
+    console.error("[schedule-link]", message);
+    return c.json({ error: message }, 500);
+  }
+});
+app.get("/schedule-actions", auth2, async (c) => {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
+  const r = await memoryCall("listScheduledActionsTool", {}, key);
+  return c.json(r);
+});
+app.post("/schedule-actions", auth2, async (c) => {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
+  const body = await c.req.json().catch(() => ({}));
+  const r = await memoryCall("createScheduledActionTool", body, key);
+  return c.json(r);
+});
+app.post("/schedule-actions/propose", auth2, async (c) => {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
+  const body = await c.req.json().catch(() => ({}));
+  const r = await memoryCall("proposeScheduledActionTool", body, key);
+  return c.json(r);
+});
+app.post("/schedule-actions/:id/pause", auth2, async (c) => {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
+  const r = await memoryCall("pauseScheduledActionTool", { id: c.req.param("id") }, key);
+  return c.json(r);
+});
+app.post("/schedule-actions/:id/resume", auth2, async (c) => {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
+  const r = await memoryCall("resumeScheduledActionTool", { id: c.req.param("id") }, key);
+  return c.json(r);
+});
+app.delete("/schedule-actions/:id", auth2, async (c) => {
+  const user = c.get("user");
+  const { key, error } = await getOrCreateUserMemoryKey(user);
+  if (!key) return c.json({ ok: false, error: error ?? "memory unavailable" }, 503);
+  const r = await memoryCall("deleteScheduledActionTool", { id: c.req.param("id") }, key);
+  return c.json(r);
+});
+app.post("/schedule-link/revoke", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const { key, error } = await getOrCreateUserMemoryKey(user);
+    if (!key) return c.json({ error: error ?? "memory unavailable" }, 503);
+    const r = await memoryCall("revokeScheduleLinkTool", {}, key);
+    return c.json(r);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to revoke schedule link.";
+    console.error("[schedule-link/revoke]", message);
+    return c.json({ error: message }, 500);
+  }
+});
+app.post("/support/submit", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const body = await c.req.json().catch(() => ({}));
+    const message = body.message?.trim();
+    if (!message) return c.json({ error: "message is required" }, 400);
+    if (message.length > 8e3) return c.json({ error: "message is too long (max 8000 characters)" }, 400);
+    const inboxKey = process.env.SUPPORT_INBOX_MEMORY_KEY?.trim();
+    if (!inboxKey) return c.json({ error: "support inbox is not configured" }, 503);
+    const stamp = (/* @__PURE__ */ new Date()).toISOString();
+    const path5 = `support/${stamp.replace(/[:.]/g, "-")}-user-${user.id}`;
+    const title = `Support request from ${user.email} (user #${user.id})`;
+    const content = [
+      `**From:** ${user.email} (user #${user.id})`,
+      `**Submitted:** ${stamp}`,
+      "",
+      "**Message:**",
+      message
+    ].join("\n");
+    const r = await memoryCall("putTool", { vault: "Issues", path: path5, title, content }, inboxKey);
+    if (!r.ok) return c.json({ error: r.error ?? "failed to submit support request" }, 502);
+    return c.json({ ok: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to submit support request.";
+    console.error("[support/submit]", message);
+    return c.json({ error: message }, 500);
+  }
+});
 app.get("/memory/usage", auth2, async (c) => {
   const user = c.get("user");
   try {
@@ -19522,7 +20431,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-NV4GTIRG.js");
+  const { drainQueue } = await import("./worker-FNSBPP7Y.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([
@@ -19539,6 +20448,7 @@ app.route("/api/internal/site-architecture-auditor", siteAuditApp);
 app.route("/youtube", youtubeApp);
 app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
+app.route("/google-ads", googleAdsApp);
 app.route("/instagram", instagramApp);
 app.route("/reddit", redditApp);
 app.route("/maps", mapsApp);
@@ -19548,6 +20458,7 @@ app.route("/serp-intelligence", serpIntelligenceApp);
 app.route("/mcp", mcpApp);
 app.route("/agent", buildBrowserAgentRoutes());
 app.route("/chat", chatApp);
+app.route("/schedule", scheduleApp);
 app.get("/console", (c) => c.html(renderConsoleHtml()));
 app.get("/console/auth/:id", async (c) => {
   const id = c.req.param("id");
@@ -19671,4 +20582,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-IDDX7KGT.js.map
+//# sourceMappingURL=server-CZT7EULY.js.map