mcp-scraper 0.33.6 → 0.34.0

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

@@ -6,16 +6,21 @@ import {
   createHarvestAttemptRecorder,
   harvestProblemResponse,
   serializeHarvestProblem
-} from "./chunk-C2OD4ELT.js";
+} from "./chunk-3HBPKR5G.js";
 import {
+  BACKUP_LAST_RESORT_ATTEMPTS,
   BrowserDriver,
   MapsSelectors,
+  backupProxyAvailable,
   buildYouTubeChannelVideosUrl,
+  cleanupBackupProxyId,
+  createBackupProxyIdSafe,
   deleteKernelProxyId,
   harvest,
+  resolveBackupKernelProxyId,
   resolveKernelProxyId,
   serpArrivalUrl
-} from "./chunk-A54ELKJK.js";
+} from "./chunk-4KQVIYIH.js";
 import {
   HttpMcpToolExecutor,
   assessTranscriptSignal,
@@ -35,7 +40,7 @@ import {
   sanitizeAttempts,
   sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-6ZUK4H66.js";
+} from "./chunk-J32XSMJI.js";
 import {
   auditImages,
   buildLinkReport,
@@ -52,7 +57,7 @@ import {
   recordKernelSession,
   recordVendorUsage,
   runWithCostContext
-} from "./chunk-WJJTGRK4.js";
+} from "./chunk-V36LS5YV.js";
 import {
   csvRecords,
   listWorkflowDefinitions,
@@ -64,7 +69,7 @@ import {
   workflowOutputBaseDir,
   workflowStepCount,
   workflowSupportsSteps
-} from "./chunk-AT2PFWHW.js";
+} from "./chunk-ZID3WQID.js";
 import "./chunk-K443GQY5.js";
 import {
   DEFAULT_MAPS_PROXY_MODE,
@@ -75,8 +80,8 @@ import {
   RawMapsHoursRowSchema,
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
-} from "./chunk-V73MPRU6.js";
-import "./chunk-F65IIUHI.js";
+} from "./chunk-CB5C3BPB.js";
+import "./chunk-NFMIHEYE.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -87,7 +92,7 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-XL6YIWJ3.js";
+} from "./chunk-SUOHUXQS.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -122,12 +127,17 @@ import {
   browserActiveCostMc,
   calculateConnectedUsageCharge,
   concurrencySlotBillingInfo,
+  getPrivateOfferPayload,
   getPublicRatesPayload,
   insufficientBalanceResponse,
   mcToCredits,
+  offerClaimPathForTier,
   serpActualCostMc,
+  tierAmountChargedUsd,
+  tierBillingInterval,
+  tierCreditsPerInterval,
   vendorCostUsdToMc
-} from "./chunk-LKIP7VDN.js";
+} from "./chunk-JBSGBSGT.js";
 import {
   CaptchaError,
   ExtractionError,
@@ -159,8 +169,10 @@ import {
   expireOldLots,
   failJob,
   failWorkflowRunRecord,
+  getBillingLedgerSummary,
   getClient,
   getDb,
+  getInboxMessage,
   getJob,
   getLedger,
   getMemoryPlan,
@@ -177,10 +189,13 @@ import {
   getWorkflowRun,
   getWorkflowRunStepState,
   getWorkflowSchedule,
+  insertInboxMessage,
   ledgerExistsForOperation,
   ledgerExistsForStripePI,
+  listActiveUserIds,
   listDueWorkflowSchedules,
   listHarvestAttempts,
+  listInboxMessages,
   listJobs,
   listRequestEvents,
   listUsers,
@@ -188,6 +203,7 @@ import {
   listWorkflowRuns,
   listWorkflowSchedules,
   logRequestEvent,
+  markInboxMessageOpened,
   markWorkflowRunRunning,
   markWorkflowScheduleRan,
   patchWorkflowSchedule,
@@ -211,9 +227,10 @@ import {
   setSubscriptionTier,
   setUserMemoryCreds,
   settleDebitMcIdempotent,
+  softDeleteInboxMessage,
   upsertPageSnapshot,
   verifyPassword
-} from "./chunk-AIK7WQD5.js";
+} from "./chunk-62DQAWPF.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -5065,7 +5082,7 @@ async function extractSite(opts) {
 }
 
 // src/api/server.ts
-import { Hono as Hono25 } from "hono";
+import { Hono as Hono26 } from "hono";
 import { serve as serveInngest } from "inngest/hono";
 
 // src/inngest/client.ts
@@ -7371,7 +7388,7 @@ var siteExtractFn = inngest.createFunction(
       return buildSeoAudit(pages, job.startUrl);
     }) : null;
     const artifacts = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-YNXTFCC3.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-GPZRLBVY.js");
       const stored = await assembleExtractArtifacts(job, { branding, imageAudit, seoAudit });
       await completeExtractJob(jobId, stored);
       return stored;
@@ -8606,8 +8623,14 @@ async function provisionMemoryForUser(user) {
   } catch {
   }
 }
+function tierIncludesMemory(subscriptionTier) {
+  if (!subscriptionTier) return false;
+  return !!SUBSCRIPTION_TIER_BY_KEY[subscriptionTier]?.includes_memory;
+}
 function resolveEffectiveMemoryPlan(user) {
-  return user.memory_plan === "pro" || user.memory_plan === "team" ? user.memory_plan : "free";
+  if (user.memory_plan === "team") return "team";
+  if (tierIncludesMemory(user.subscription_tier)) return "pro";
+  return user.memory_plan === "pro" ? "pro" : "free";
 }
 async function getOrCreateUserMemoryKey(user) {
   const creds = await getUserMemoryCreds(user.id);
@@ -8808,37 +8831,120 @@ internalBillingApp.post("/scheduled-run/void", async (c) => {
   }
 });
 
+// src/api/inbox-routes.ts
+import { Hono as Hono4 } from "hono";
+import { z as z11 } from "zod";
+
+// src/api/api-auth.ts
+import { createMiddleware as createMiddleware2 } from "hono/factory";
+function createApiKeyAuth() {
+  return createMiddleware2(async (c, next) => {
+    const key = c.req.header("x-api-key");
+    if (!key) return c.json({ error: "Missing API key" }, 401);
+    const user = await getUserByApiKey(key);
+    if (!user) return c.json({ error: "Invalid or inactive API key" }, 401);
+    c.set("user", user);
+    return next();
+  });
+}
+
+// src/api/inbox-routes.ts
+var inboxApp = new Hono4();
+inboxApp.use("*", createApiKeyAuth());
+inboxApp.get("/", async (c) => {
+  const messages = await listInboxMessages(c.get("user").id);
+  return c.json({ ok: true, messages });
+});
+inboxApp.get("/:id", async (c) => {
+  const message = await getInboxMessage(c.get("user").id, c.req.param("id"));
+  if (!message) return c.json({ ok: false, error: "Message not found" }, 404);
+  return c.json({ ok: true, message });
+});
+inboxApp.post("/:id/opened", async (c) => {
+  const openedAt = await markInboxMessageOpened(c.get("user").id, c.req.param("id"));
+  if (openedAt === null) return c.json({ ok: false, error: "Message not found" }, 404);
+  return c.json({ ok: true, opened_at: openedAt });
+});
+inboxApp.delete("/:id", async (c) => {
+  const deleted = await softDeleteInboxMessage(c.get("user").id, c.req.param("id"));
+  if (!deleted) return c.json({ ok: false, error: "Message not found" }, 404);
+  return c.json({ ok: true });
+});
+var broadcastSchema = z11.object({
+  subject: z11.string().min(1).max(500),
+  body_md: z11.string().min(1).max(2e5),
+  recipients: z11.union([z11.literal("all"), z11.array(z11.string().min(1).max(320)).min(1).max(1e3)])
+});
+function internalRequestAuthorized2(header) {
+  const expected = process.env.INTERNAL_BILLING_SECRET ?? process.env.INTERNAL_MEMORY_DEBIT_SECRET;
+  return Boolean(expected && header && header === expected);
+}
+var internalInboxApp = new Hono4();
+internalInboxApp.use("*", async (c, next) => {
+  if (!internalRequestAuthorized2(c.req.header("x-internal-secret"))) {
+    return c.json({ ok: false, error_code: "unauthorized", error: "unauthorized" }, 401);
+  }
+  await next();
+});
+internalInboxApp.post("/broadcast", async (c) => {
+  const parsed = broadcastSchema.safeParse(await c.req.json().catch(() => null));
+  if (!parsed.success) {
+    return c.json({ ok: false, error_code: "invalid_request", error: "invalid inbox broadcast request" }, 400);
+  }
+  const { subject, body_md, recipients } = parsed.data;
+  const skipped = [];
+  const userIds = [];
+  if (recipients === "all") {
+    userIds.push(...await listActiveUserIds());
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    for (const email of recipients) {
+      const user = await getUserByEmail(email.trim().toLowerCase());
+      if (!user || seen.has(user.id)) {
+        skipped.push(email);
+        continue;
+      }
+      seen.add(user.id);
+      userIds.push(user.id);
+    }
+  }
+  for (const userId of userIds) {
+    await insertInboxMessage(userId, subject, body_md, "operator");
+  }
+  return c.json({ ok: true, delivered: userIds.length, skipped });
+});
+
 // src/api/connected-usage-billing.ts
 import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var CONNECTED_USAGE_BILLING_CLASS = "connected_usage";
 var CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE = "mastra_scheduler";
-var ConnectedUsageSafeMetadataSchema = z11.object({
-  toolName: z11.string().trim().min(1).max(200).optional(),
-  operationKind: z11.enum(["read", "action", "sync", "export", "proxy", "other"]).optional(),
-  outcome: z11.enum(["success", "error", "partial"]).optional(),
-  requestId: z11.string().trim().min(1).max(200).optional(),
-  occurrenceId: z11.string().trim().min(1).max(200).optional(),
-  scheduleId: z11.string().trim().min(1).max(200).optional(),
-  nangoOperationId: z11.string().trim().min(1).max(200).optional(),
-  startedAt: z11.string().datetime({ offset: true }).optional(),
-  completedAt: z11.string().datetime({ offset: true }).optional()
+var ConnectedUsageSafeMetadataSchema = z12.object({
+  toolName: z12.string().trim().min(1).max(200).optional(),
+  operationKind: z12.enum(["read", "action", "sync", "export", "proxy", "other"]).optional(),
+  outcome: z12.enum(["success", "error", "partial"]).optional(),
+  requestId: z12.string().trim().min(1).max(200).optional(),
+  occurrenceId: z12.string().trim().min(1).max(200).optional(),
+  scheduleId: z12.string().trim().min(1).max(200).optional(),
+  nangoOperationId: z12.string().trim().min(1).max(200).optional(),
+  startedAt: z12.string().datetime({ offset: true }).optional(),
+  completedAt: z12.string().datetime({ offset: true }).optional()
 }).strict();
-var ConnectedUsageSettlementInputSchema = z11.object({
-  identity: z11.string().trim().min(1).max(320),
-  idempotencyKey: z11.string().trim().min(1).max(500),
-  ratePolicyVersion: z11.string().trim().min(1).max(100),
-  connectionId: z11.string().trim().min(1).max(500),
-  providerConfigKey: z11.string().trim().min(1).max(200),
-  functionRuns: z11.number().int().safe().nonnegative(),
-  proxyRequests: z11.number().int().safe().nonnegative(),
-  computeMilliseconds: z11.number().int().safe().nonnegative(),
-  sourceSurface: z11.enum(["main_mcp", "mastra_scheduler", "nango_reconciliation"]).default(CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE),
+var ConnectedUsageSettlementInputSchema = z12.object({
+  identity: z12.string().trim().min(1).max(320),
+  idempotencyKey: z12.string().trim().min(1).max(500),
+  ratePolicyVersion: z12.string().trim().min(1).max(100),
+  connectionId: z12.string().trim().min(1).max(500),
+  providerConfigKey: z12.string().trim().min(1).max(200),
+  functionRuns: z12.number().int().safe().nonnegative(),
+  proxyRequests: z12.number().int().safe().nonnegative(),
+  computeMilliseconds: z12.number().int().safe().nonnegative(),
+  sourceSurface: z12.enum(["main_mcp", "mastra_scheduler", "nango_reconciliation"]).default(CONNECTED_USAGE_DEFAULT_SOURCE_SURFACE),
   metadata: ConnectedUsageSafeMetadataSchema.optional()
 }).strict();
-var ConnectedUsagePreflightInputSchema = z11.object({
-  identity: z11.string().trim().min(1).max(320),
-  ratePolicyVersion: z11.string().trim().min(1).max(100)
+var ConnectedUsagePreflightInputSchema = z12.object({
+  identity: z12.string().trim().min(1).max(320),
+  ratePolicyVersion: z12.string().trim().min(1).max(100)
 }).strict();
 var ConnectedUsageBillingError = class extends Error {
   constructor(code, message, httpStatus, details = {}) {
@@ -9214,8 +9320,249 @@ async function listConnectedUsageHistory(userId, limit = 100) {
   return history;
 }
 
+// src/api/connected-account-billing.ts
+var DEFAULT_CONNECTED_ACCOUNT_PRICE_ID = "price_1TtYPAS8aAcsk3TGHOgrDZiQ";
+async function ensureConnectedAccountBillingSchema() {
+  await getDb().execute(`CREATE TABLE IF NOT EXISTS connected_account_billing (
+    user_id INTEGER PRIMARY KEY,
+    stripe_subscription_id TEXT,
+    stripe_subscription_item_id TEXT,
+    price_id TEXT,
+    quantity INTEGER NOT NULL DEFAULT 0,
+    status TEXT NOT NULL DEFAULT 'pending',
+    last_error_code TEXT,
+    synced_at TEXT,
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+}
+async function getConnectedAccountBillingState(userId) {
+  await ensureConnectedAccountBillingSchema();
+  const result = await getDb().execute({
+    sql: "SELECT * FROM connected_account_billing WHERE user_id = ? LIMIT 1",
+    args: [Number(userId)]
+  });
+  return result.rows[0] ? result.rows[0] : null;
+}
+async function setConnectedAccountBillingState(input) {
+  await ensureConnectedAccountBillingSchema();
+  await getDb().execute({
+    sql: `INSERT INTO connected_account_billing
+      (user_id, stripe_subscription_id, stripe_subscription_item_id, price_id, quantity, status, last_error_code, synced_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, CASE WHEN ? THEN datetime('now') ELSE NULL END, datetime('now'))
+      ON CONFLICT(user_id) DO UPDATE SET
+        stripe_subscription_id = excluded.stripe_subscription_id,
+        stripe_subscription_item_id = excluded.stripe_subscription_item_id,
+        price_id = excluded.price_id,
+        quantity = excluded.quantity,
+        status = excluded.status,
+        last_error_code = excluded.last_error_code,
+        synced_at = CASE WHEN ? THEN datetime('now') ELSE connected_account_billing.synced_at END,
+        updated_at = datetime('now')`,
+    args: [
+      Number(input.userId),
+      input.stripeSubscriptionId,
+      input.stripeSubscriptionItemId,
+      input.priceId,
+      input.quantity,
+      input.status,
+      input.lastErrorCode,
+      input.synced ? 1 : 0,
+      input.synced ? 1 : 0
+    ]
+  });
+  const state = await getConnectedAccountBillingState(input.userId);
+  if (!state) throw new Error("connected account billing state was not persisted");
+  return state;
+}
+var ConnectedAccountBillingError = class extends Error {
+  constructor(message, code, status = 409, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "ConnectedAccountBillingError";
+  }
+  code;
+  status;
+  details;
+};
+function connectedAccountPriceId() {
+  const configured = process.env.CONNECTED_ACCOUNT_PRICE_ID?.trim();
+  if (configured) return configured;
+  return DEFAULT_CONNECTED_ACCOUNT_PRICE_ID || null;
+}
+function connectedAccountBillingView(actualQuantity, state) {
+  const quantity = Math.max(0, Math.round(actualQuantity));
+  return {
+    provider: "nango",
+    billingMode: "flat_recurring_credits",
+    priceId: connectedAccountPriceId(),
+    unitAmountCredits: CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
+    interval: "month",
+    quantity,
+    projectedMonthlyCredits: quantity * CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
+    status: state?.status ?? "pending",
+    lastErrorCode: state?.last_error_code ?? null,
+    syncedAt: state?.synced_at ?? null,
+    usage: CONNECTED_USAGE_RATE_POLICY.usage
+  };
+}
+function findBasePlanItem(subscription) {
+  return subscription.items.data.find((item) => !!item.price?.id && item.price.id in SUBSCRIPTION_TIERS);
+}
+function safeErrorCode(error) {
+  if (error instanceof ConnectedAccountBillingError) return error.code;
+  return "stripe_connection_billing_failed";
+}
+async function persistFailure(user, quantityToPersist, error) {
+  await setConnectedAccountBillingState({
+    userId: user.id,
+    stripeSubscriptionId: user.subscription_id,
+    stripeSubscriptionItemId: null,
+    priceId: connectedAccountPriceId(),
+    quantity: quantityToPersist,
+    status: error instanceof ConnectedAccountBillingError && error.code !== "stripe_connection_billing_failed" ? "blocked" : "error",
+    lastErrorCode: safeErrorCode(error),
+    synced: false
+  });
+}
+async function reconcileConnectedAccountBilling(user, actualQuantity) {
+  if (!Number.isSafeInteger(actualQuantity) || actualQuantity < 0) {
+    throw new Error("actualQuantity must be a non-negative safe integer");
+  }
+  const priceId = connectedAccountPriceId();
+  if (!priceId) {
+    const error = new ConnectedAccountBillingError(
+      "Connected-account billing is not configured.",
+      "connected_account_price_not_configured",
+      503
+    );
+    await persistFailure(user, actualQuantity, error);
+    throw error;
+  }
+  if (!user.subscription_id || !(user.subscription_tier ?? "") || !Object.values(SUBSCRIPTION_TIERS).some((t) => t.tier === user.subscription_tier)) {
+    if (actualQuantity === 0) {
+      const state = await setConnectedAccountBillingState({
+        userId: user.id,
+        stripeSubscriptionId: null,
+        stripeSubscriptionItemId: null,
+        priceId,
+        quantity: 0,
+        status: "synced",
+        lastErrorCode: null,
+        synced: true
+      });
+      return connectedAccountBillingView(0, state);
+    }
+    const error = new ConnectedAccountBillingError(
+      "An active paid plan is required before connected accounts can be billed.",
+      "paid_plan_required",
+      403
+    );
+    await persistFailure(user, actualQuantity, error);
+    throw error;
+  }
+  const existingState = await getConnectedAccountBillingState(user.id);
+  const currentQuantity = Math.max(0, existingState?.quantity ?? 0);
+  try {
+    if (actualQuantity > currentQuantity) {
+      const newConnections = actualQuantity - currentQuantity;
+      const feeMc = newConnections * CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC;
+      const debit = await debitMc(
+        user.id,
+        feeMc,
+        LedgerOperation.CONNECTED_ACCOUNT_FEE,
+        `${newConnections} connected account${newConnections === 1 ? "" : "s"} at ${CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS} credits/month`
+      );
+      if (!debit.ok) {
+        const requiredMc = feeMc;
+        const error = new ConnectedAccountBillingError(
+          `Insufficient credits to connect. Balance: ${mcToCredits(debit.balance_mc)} credits. Connecting requires ${mcToCredits(requiredMc)} credits (${mcToCredits(requiredMc - debit.balance_mc)} short). Upgrade your plan or wait for your credits to refresh.`,
+          "insufficient_credits",
+          402,
+          {
+            balanceCredits: mcToCredits(debit.balance_mc),
+            requiredCredits: mcToCredits(requiredMc),
+            shortByCredits: mcToCredits(Math.max(0, requiredMc - debit.balance_mc))
+          }
+        );
+        await persistFailure(user, currentQuantity, error);
+        throw error;
+      }
+    }
+    const state = await setConnectedAccountBillingState({
+      userId: user.id,
+      stripeSubscriptionId: user.subscription_id,
+      stripeSubscriptionItemId: null,
+      priceId,
+      quantity: actualQuantity,
+      status: "synced",
+      lastErrorCode: null,
+      synced: true
+    });
+    return connectedAccountBillingView(actualQuantity, state);
+  } catch (error) {
+    if (error instanceof ConnectedAccountBillingError) throw error;
+    await persistFailure(user, currentQuantity, error);
+    throw new ConnectedAccountBillingError(
+      "Unable to update connected-account billing.",
+      "stripe_connection_billing_failed",
+      503
+    );
+  }
+}
+async function currentConnectedAccountBillingView(userId, actualQuantity) {
+  return connectedAccountBillingView(actualQuantity, await getConnectedAccountBillingState(userId));
+}
+
+// src/api/billing-summary.ts
+var allOperations = Object.values(LedgerOperation);
+var LEDGER_OPERATION_CLASSIFICATION = {
+  refund: allOperations.filter((op) => op === LedgerOperation.REFUND || op.endsWith("_refund")),
+  grant: [LedgerOperation.SUBSCRIPTION, LedgerOperation.SIGNUP_GRANT, LedgerOperation.MONTHLY_REFRESH],
+  purchase: [LedgerOperation.TOPUP]
+};
+function resolveBillingSummaryWindow(raw, now = /* @__PURE__ */ new Date()) {
+  if (raw === "30d") {
+    return { window: "30d", since: new Date(now.getTime() - 30 * 24 * 60 * 60 * 1e3) };
+  }
+  return { window: "month", since: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1)) };
+}
+function toSqliteUtc(date) {
+  return date.toISOString().slice(0, 19).replace("T", " ");
+}
+async function billingSummaryHandler(c) {
+  const raw = c.req.query("window");
+  if (raw !== void 0 && raw !== "month" && raw !== "30d") {
+    return c.json({ ok: false, error: "window must be 'month' or '30d'" }, 400);
+  }
+  const user = c.get("user");
+  const { window: window2, since } = resolveBillingSummaryWindow(raw);
+  const [summary, connectedState] = await Promise.all([
+    getBillingLedgerSummary(user.id, toSqliteUtc(since), LEDGER_OPERATION_CLASSIFICATION),
+    getConnectedAccountBillingState(user.id)
+  ]);
+  const connectedQuantity = Math.max(0, Math.round(Number(connectedState?.quantity ?? 0)));
+  c.header("Cache-Control", "no-store");
+  return c.json({
+    ok: true,
+    window: window2,
+    since: since.toISOString(),
+    balance_mc: user.balance_mc,
+    totals: {
+      spent_mc: summary.spent_mc,
+      refunded_mc: summary.refunded_mc,
+      granted_mc: summary.granted_mc,
+      purchased_mc: summary.purchased_mc,
+      net_mc: summary.net_mc
+    },
+    by_operation: summary.by_operation,
+    connected_monthly_mc: connectedQuantity * CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC
+  });
+}
+
 // src/api/youtube-routes.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 
 // src/youtube/youtube-harvest.ts
 import { promises as fs } from "fs";
@@ -9223,17 +9570,17 @@ import path4 from "path";
 import Papa from "papaparse";
 
 // src/youtube/schemas.ts
-import { z as z12 } from "zod";
-var YouTubeHarvestOptionsSchema = z12.object({
-  mode: z12.enum(["search", "channel"]),
-  query: z12.string().optional(),
-  channelHandle: z12.string().optional(),
-  maxVideos: z12.number().int().min(1).max(5e3).default(100),
-  downloadMp3: z12.boolean().default(false),
-  outputDir: z12.string().default("./yt-output"),
-  kernelApiKey: z12.string().optional(),
-  kernelProxyId: z12.string().optional(),
-  headless: z12.boolean().default(false)
+import { z as z13 } from "zod";
+var YouTubeHarvestOptionsSchema = z13.object({
+  mode: z13.enum(["search", "channel"]),
+  query: z13.string().optional(),
+  channelHandle: z13.string().optional(),
+  maxVideos: z13.number().int().min(1).max(5e3).default(100),
+  downloadMp3: z13.boolean().default(false),
+  outputDir: z13.string().default("./yt-output"),
+  kernelApiKey: z13.string().optional(),
+  kernelProxyId: z13.string().optional(),
+  headless: z13.boolean().default(false)
 }).refine(
   (o) => o.mode === "search" ? !!o.query : !!o.channelHandle,
   { message: "search mode requires query; channel mode requires channelHandle" }
@@ -10005,78 +10352,66 @@ async function fetchCaptions(videoId) {
   );
 }
 
-// src/api/api-auth.ts
-import { createMiddleware as createMiddleware2 } from "hono/factory";
-function createApiKeyAuth() {
-  return createMiddleware2(async (c, next) => {
-    const key = c.req.header("x-api-key");
-    if (!key) return c.json({ error: "Missing API key" }, 401);
-    const user = await getUserByApiKey(key);
-    if (!user) return c.json({ error: "Invalid or inactive API key" }, 401);
-    c.set("user", user);
-    return next();
-  });
-}
-
 // src/api/server-schemas.ts
-import { z as z13 } from "zod";
-var HarvestBodySchema = z13.object({
-  query: z13.string().min(1, "query is required"),
-  location: z13.string().optional(),
-  depth: z13.number().int().min(1).max(4).optional(),
-  maxQuestions: z13.number().int().min(1).optional(),
-  callback_url: z13.string().url().optional(),
-  gl: z13.string().optional(),
-  hl: z13.string().optional(),
-  device: z13.enum(["desktop", "mobile"]).optional(),
-  proxyMode: z13.enum(["configured", "none"]).optional(),
-  proxyZip: z13.string().regex(/^\d{5}$/).optional(),
-  debug: z13.boolean().optional(),
-  serpOnly: z13.boolean().optional(),
-  pages: z13.number().int().min(1).max(2).optional()
-});
-var ExtractUrlBodySchema = z13.object({
-  url: z13.string().min(1, "url is required"),
-  screenshot: z13.boolean().optional(),
-  screenshotDevice: z13.enum(["desktop", "mobile"]).optional(),
-  extractBranding: z13.boolean().optional(),
-  downloadMedia: z13.boolean().optional(),
-  mediaTypes: z13.array(z13.enum(["image", "video", "audio"])).optional(),
-  allowLocal: z13.boolean().optional(),
-  depositToVault: z13.boolean().optional(),
-  vaultName: z13.string().trim().min(1).max(120).optional()
-});
-var DiffPageBodySchema = z13.object({
-  url: z13.string().min(1, "url is required"),
-  allowLocal: z13.boolean().optional(),
-  resetBaseline: z13.boolean().optional()
-});
-var MapUrlsBodySchema = z13.object({
-  url: z13.string().min(1, "url is required"),
-  maxUrls: z13.number().int().min(1).max(2e3).optional(),
-  concurrency: z13.number().int().min(1).max(20).optional(),
-  browserFallback: z13.boolean().optional(),
-  kernelFallback: z13.boolean().optional()
-});
-var ExtractSiteBodySchema = z13.object({
-  url: z13.string().min(1, "url is required"),
-  maxPages: z13.number().int().min(1).max(1e4).optional(),
-  browserFallback: z13.boolean().optional(),
-  kernelFallback: z13.boolean().optional(),
-  rotateProxies: z13.boolean().optional(),
-  rotateProxyEvery: z13.number().int().min(1).max(100).optional(),
-  background: z13.boolean().optional(),
-  downloadImages: z13.boolean().optional(),
-  formats: z13.array(z13.enum(["markdown", "links", "json", "images", "branding", "issues"])).optional()
-});
-var YoutubeHarvestBodySchema = z13.object({
-  mode: z13.enum(["search", "channel"]),
-  query: z13.string().optional(),
-  channelHandle: z13.string().optional(),
-  maxVideos: z13.number().int().min(1).max(500).optional()
-});
-var YoutubeTranscribeBodySchema = z13.object({
-  videoId: z13.string().min(1, "videoId is required")
+import { z as z14 } from "zod";
+var HarvestBodySchema = z14.object({
+  query: z14.string().min(1, "query is required"),
+  location: z14.string().optional(),
+  depth: z14.number().int().min(1).max(4).optional(),
+  maxQuestions: z14.number().int().min(1).optional(),
+  callback_url: z14.string().url().optional(),
+  gl: z14.string().optional(),
+  hl: z14.string().optional(),
+  device: z14.enum(["desktop", "mobile"]).optional(),
+  proxyMode: z14.enum(["configured", "none"]).optional(),
+  proxyZip: z14.string().regex(/^\d{5}$/).optional(),
+  debug: z14.boolean().optional(),
+  serpOnly: z14.boolean().optional(),
+  pages: z14.number().int().min(1).max(2).optional(),
+  recency: z14.enum(["day", "week", "month", "year"]).optional()
+});
+var ExtractUrlBodySchema = z14.object({
+  url: z14.string().min(1, "url is required"),
+  screenshot: z14.boolean().optional(),
+  screenshotDevice: z14.enum(["desktop", "mobile"]).optional(),
+  extractBranding: z14.boolean().optional(),
+  downloadMedia: z14.boolean().optional(),
+  mediaTypes: z14.array(z14.enum(["image", "video", "audio"])).optional(),
+  allowLocal: z14.boolean().optional(),
+  depositToVault: z14.boolean().optional(),
+  vaultName: z14.string().trim().min(1).max(120).optional()
+});
+var DiffPageBodySchema = z14.object({
+  url: z14.string().min(1, "url is required"),
+  allowLocal: z14.boolean().optional(),
+  resetBaseline: z14.boolean().optional()
+});
+var MapUrlsBodySchema = z14.object({
+  url: z14.string().min(1, "url is required"),
+  maxUrls: z14.number().int().min(1).max(2e3).optional(),
+  concurrency: z14.number().int().min(1).max(20).optional(),
+  browserFallback: z14.boolean().optional(),
+  kernelFallback: z14.boolean().optional()
+});
+var ExtractSiteBodySchema = z14.object({
+  url: z14.string().min(1, "url is required"),
+  maxPages: z14.number().int().min(1).max(1e4).optional(),
+  browserFallback: z14.boolean().optional(),
+  kernelFallback: z14.boolean().optional(),
+  rotateProxies: z14.boolean().optional(),
+  rotateProxyEvery: z14.number().int().min(1).max(100).optional(),
+  background: z14.boolean().optional(),
+  downloadImages: z14.boolean().optional(),
+  formats: z14.array(z14.enum(["markdown", "links", "json", "images", "branding", "issues"])).optional()
+});
+var YoutubeHarvestBodySchema = z14.object({
+  mode: z14.enum(["search", "channel"]),
+  query: z14.string().optional(),
+  channelHandle: z14.string().optional(),
+  maxVideos: z14.number().int().min(1).max(500).optional()
+});
+var YoutubeTranscribeBodySchema = z14.object({
+  videoId: z14.string().min(1, "videoId is required")
 });
 
 // src/api/concurrency-gates.ts
@@ -10254,7 +10589,7 @@ async function extendConcurrencyGate(lockId, ttlSeconds = DEFAULT_LOCK_TTL_SECON
 }
 
 // src/api/youtube-routes.ts
-var youtubeApp = new Hono4();
+var youtubeApp = new Hono5();
 youtubeApp.post("/harvest", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = YoutubeHarvestBodySchema.safeParse(raw);
@@ -10413,14 +10748,14 @@ function fmtTs(secs) {
 }
 
 // src/api/screenshot-routes.ts
-import { Hono as Hono5 } from "hono";
-import { z as z14 } from "zod";
-var ScreenshotBodySchema = z14.object({
-  url: z14.string().trim().min(1, "url is required"),
-  device: z14.string().trim().optional(),
-  allowLocal: z14.boolean().optional()
+import { Hono as Hono6 } from "hono";
+import { z as z15 } from "zod";
+var ScreenshotBodySchema = z15.object({
+  url: z15.string().trim().min(1, "url is required"),
+  device: z15.string().trim().optional(),
+  allowLocal: z15.boolean().optional()
 });
-var screenshotApp = new Hono5();
+var screenshotApp = new Hono6();
 screenshotApp.use("*", createApiKeyAuth());
 screenshotApp.post("/", async (c) => {
   const raw = await c.req.json().catch(() => ({}));
@@ -10477,8 +10812,8 @@ screenshotApp.post("/", async (c) => {
 });
 
 // src/api/facebook-ad-routes.ts
-import { Hono as Hono6 } from "hono";
-import { z as z15 } from "zod";
+import { Hono as Hono7 } from "hono";
+import { z as z16 } from "zod";
 
 // src/extractor/FacebookAdExtractor.ts
 var SPRITE_Y_TO_PLATFORM = {
@@ -11371,35 +11706,35 @@ async function extractFacebookOrganicVideoFromPage(page, sourceUrl, quality = "b
 
 // src/api/facebook-ad-routes.ts
 import { fal } from "@fal-ai/client";
-var FacebookAdBodySchema = z15.object({
-  url: z15.string().trim().optional(),
-  libraryId: z15.string().trim().optional(),
-  openModal: z15.boolean().optional()
+var FacebookAdBodySchema = z16.object({
+  url: z16.string().trim().optional(),
+  libraryId: z16.string().trim().optional(),
+  openModal: z16.boolean().optional()
 }).refine((d) => !!d.url || !!d.libraryId, { message: "url or libraryId is required" });
-var FacebookPageIntelBodySchema = z15.object({
-  pageId: z15.string().trim().optional(),
-  query: z15.string().trim().optional(),
-  libraryId: z15.string().trim().optional(),
-  maxAds: z15.number().int().min(1).max(200).optional(),
-  country: z15.string().trim().toUpperCase().optional()
+var FacebookPageIntelBodySchema = z16.object({
+  pageId: z16.string().trim().optional(),
+  query: z16.string().trim().optional(),
+  libraryId: z16.string().trim().optional(),
+  maxAds: z16.number().int().min(1).max(200).optional(),
+  country: z16.string().trim().toUpperCase().optional()
 }).refine((d) => !!d.pageId || !!d.query || !!d.libraryId, {
   message: "pageId, libraryId, or query is required"
 });
-var FacebookTranscribeBodySchema = z15.object({
-  videoUrl: z15.string().trim().min(1, "videoUrl is required")
+var FacebookTranscribeBodySchema = z16.object({
+  videoUrl: z16.string().trim().min(1, "videoUrl is required")
 });
-var FacebookVideoTranscribeBodySchema = z15.object({
-  url: z15.string().trim().min(1, "url is required"),
-  quality: z15.enum(["best", "hd", "sd"]).default("best")
+var FacebookVideoTranscribeBodySchema = z16.object({
+  url: z16.string().trim().min(1, "url is required"),
+  quality: z16.enum(["best", "hd", "sd"]).default("best")
 });
-var FacebookSearchBodySchema = z15.object({
-  query: z15.string().trim().min(1, "query is required"),
-  country: z15.string().trim().toUpperCase().optional(),
-  maxResults: z15.number().int().min(1).max(20).optional()
+var FacebookSearchBodySchema = z16.object({
+  query: z16.string().trim().min(1, "query is required"),
+  country: z16.string().trim().toUpperCase().optional(),
+  maxResults: z16.number().int().min(1).max(20).optional()
 });
-var FacebookMediaBodySchema = z15.object({
-  url: z15.string().trim().min(1, "url is required"),
-  filename: z15.string().trim().optional()
+var FacebookMediaBodySchema = z16.object({
+  url: z16.string().trim().min(1, "url is required"),
+  filename: z16.string().trim().optional()
 });
 function invalidRequest(message) {
   return { error_code: "invalid_request", message };
@@ -11490,7 +11825,7 @@ async function kernelLaunchOptsResidential() {
   }
   return { headless: true, kernelApiKey: browserServiceApiKey(), kernelProxyId: proxyId, viewport: { width: 1280, height: 900 }, locale: "en-US" };
 }
-var facebookAdApp = new Hono6();
+var facebookAdApp = new Hono7();
 facebookAdApp.post("/ad", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = FacebookAdBodySchema.safeParse(raw);
@@ -11832,8 +12167,8 @@ facebookAdApp.post("/media", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/google-ads-routes.ts
-import { Hono as Hono7 } from "hono";
-import { z as z16 } from "zod";
+import { Hono as Hono8 } from "hono";
+import { z as z17 } from "zod";
 
 // src/extractor/GoogleAdsExtractor.ts
 var ORIGIN = "https://adstransparency.google.com";
@@ -12003,19 +12338,19 @@ var GoogleAdsExtractor = class {
 
 // src/api/google-ads-routes.ts
 import { fal as fal2 } from "@fal-ai/client";
-var GoogleAdsSearchBodySchema = z16.object({
-  query: z16.string().trim().min(1, "query is required"),
-  region: z16.string().trim().toUpperCase().length(2).optional(),
-  maxResults: z16.number().int().min(1).max(20).optional()
-});
-var GoogleAdsPageIntelBodySchema = z16.object({
-  advertiserId: z16.string().trim().optional(),
-  domain: z16.string().trim().optional(),
-  region: z16.string().trim().toUpperCase().length(2).optional(),
-  maxAds: z16.number().int().min(1).max(200).optional()
+var GoogleAdsSearchBodySchema = z17.object({
+  query: z17.string().trim().min(1, "query is required"),
+  region: z17.string().trim().toUpperCase().length(2).optional(),
+  maxResults: z17.number().int().min(1).max(20).optional()
+});
+var GoogleAdsPageIntelBodySchema = z17.object({
+  advertiserId: z17.string().trim().optional(),
+  domain: z17.string().trim().optional(),
+  region: z17.string().trim().toUpperCase().length(2).optional(),
+  maxAds: z17.number().int().min(1).max(200).optional()
 }).refine((d) => !!d.advertiserId || !!d.domain, { message: "advertiserId or domain is required" });
-var GoogleAdsTranscribeBodySchema = z16.object({
-  videoUrl: z16.string().trim().min(1, "videoUrl is required")
+var GoogleAdsTranscribeBodySchema = z17.object({
+  videoUrl: z17.string().trim().min(1, "videoUrl is required")
 });
 function invalidRequest2(message) {
   return { error_code: "invalid_request", message };
@@ -12041,7 +12376,7 @@ async function kernelLaunchOptsResidential2() {
 function isBlockedMessage(msg) {
   return msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha");
 }
-var googleAdsApp = new Hono7();
+var googleAdsApp = new Hono8();
 googleAdsApp.post("/search", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = GoogleAdsSearchBodySchema.safeParse(raw);
@@ -12157,8 +12492,8 @@ googleAdsApp.post("/transcribe", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/instagram-routes.ts
-import { Hono as Hono8 } from "hono";
-import { z as z17 } from "zod";
+import { Hono as Hono9 } from "hono";
+import { z as z18 } from "zod";
 import { mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { join as join3 } from "path";
@@ -12520,32 +12855,32 @@ async function extractInstagramMediaFromPage(page, sourceUrl, capturedMediaUrls
 }
 
 // src/api/instagram-routes.ts
-var InstagramProfileContentBodySchema = z17.object({
-  handle: z17.string().trim().optional(),
-  url: z17.string().trim().optional(),
-  profile: z17.string().trim().min(1).optional(),
-  saveProfileChanges: z17.boolean().optional(),
-  save_profile_changes: z17.boolean().optional(),
-  maxItems: z17.number().int().min(1).max(2e3).default(50),
-  maxScrolls: z17.number().int().min(0).max(250).default(10),
-  scrollDelayMs: z17.number().int().min(250).max(5e3).default(1200),
-  stableScrollLimit: z17.number().int().min(1).max(10).default(4)
+var InstagramProfileContentBodySchema = z18.object({
+  handle: z18.string().trim().optional(),
+  url: z18.string().trim().optional(),
+  profile: z18.string().trim().min(1).optional(),
+  saveProfileChanges: z18.boolean().optional(),
+  save_profile_changes: z18.boolean().optional(),
+  maxItems: z18.number().int().min(1).max(2e3).default(50),
+  maxScrolls: z18.number().int().min(0).max(250).default(10),
+  scrollDelayMs: z18.number().int().min(250).max(5e3).default(1200),
+  stableScrollLimit: z18.number().int().min(1).max(10).default(4)
 }).refine((d) => !!d.handle || !!d.url, {
   message: "handle or url is required"
 });
-var InstagramMediaTypeSchema = z17.enum(["image", "video", "audio"]);
-var InstagramMediaDownloadBodySchema = z17.object({
-  url: z17.string().trim().min(1, "url is required"),
-  profile: z17.string().trim().min(1).optional(),
-  saveProfileChanges: z17.boolean().optional(),
-  save_profile_changes: z17.boolean().optional(),
-  mediaTypes: z17.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
-  downloadMedia: z17.boolean().default(true),
-  downloadAllTracks: z17.boolean().default(false),
-  includeTranscript: z17.boolean().default(false),
-  mux: z17.boolean().default(true)
-});
-var instagramApp = new Hono8();
+var InstagramMediaTypeSchema = z18.enum(["image", "video", "audio"]);
+var InstagramMediaDownloadBodySchema = z18.object({
+  url: z18.string().trim().min(1, "url is required"),
+  profile: z18.string().trim().min(1).optional(),
+  saveProfileChanges: z18.boolean().optional(),
+  save_profile_changes: z18.boolean().optional(),
+  mediaTypes: z18.array(InstagramMediaTypeSchema).default(["image", "video", "audio"]),
+  downloadMedia: z18.boolean().default(true),
+  downloadAllTracks: z18.boolean().default(false),
+  includeTranscript: z18.boolean().default(false),
+  mux: z18.boolean().default(true)
+});
+var instagramApp = new Hono9();
 function invalidRequest3(message) {
   return { error_code: "invalid_request", message };
 }
@@ -12825,11 +13160,168 @@ instagramApp.post("/media-download", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/reddit-routes.ts
-import { Hono as Hono9 } from "hono";
-import { z as z18 } from "zod";
-var RedditThreadBodySchema = z18.object({
-  url: z18.string().trim().min(1, "url is required"),
-  maxComments: z18.number().int().min(1).max(2e3).optional()
+import { Hono as Hono10 } from "hono";
+import { z as z19 } from "zod";
+
+// src/api/reddit-trending.ts
+function buildSerpQuery(topic, subreddit) {
+  const scope = subreddit ? `site:reddit.com/r/${subreddit}` : "site:reddit.com";
+  return `${scope} ${topic}`.trim();
+}
+function subredditFromUrl(url) {
+  const m = url.match(/\/r\/([^/]+)\//i);
+  return m ? m[1] : "";
+}
+function extractRedditThreadUrls(organicResults, limit) {
+  if (!Array.isArray(organicResults)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of organicResults) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw;
+    const url = canonicalThreadUrl(r.url);
+    if (!url || seen.has(url)) continue;
+    seen.add(url);
+    out.push({
+      title: typeof r.title === "string" ? r.title.trim() : "",
+      url,
+      subreddit: subredditFromUrl(url)
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+async function mapWithConcurrency(items, concurrency, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(concurrency, items.length)) }, async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+function parseCountText(text2) {
+  if (typeof text2 !== "string") return 0;
+  const m = text2.replace(/,/g, "").match(/\d+/);
+  return m ? Number(m[0]) : 0;
+}
+function canonicalThreadUrl(href) {
+  if (typeof href !== "string" || !href.trim()) return null;
+  try {
+    const u = new URL(href.trim(), "https://old.reddit.com");
+    if (!/(^|\.)reddit\.com$/.test(u.hostname.toLowerCase())) return null;
+    if (!/\/comments\//.test(u.pathname)) return null;
+    u.hostname = "www.reddit.com";
+    u.protocol = "https:";
+    u.search = "";
+    u.hash = "";
+    return u.toString();
+  } catch {
+    return null;
+  }
+}
+function engagementScore(score, commentCount) {
+  return score + 2 * commentCount;
+}
+var INTERROGATIVE_STARTERS = /* @__PURE__ */ new Set([
+  "what",
+  "whats",
+  "how",
+  "why",
+  "when",
+  "where",
+  "who",
+  "whom",
+  "whose",
+  "which",
+  "is",
+  "are",
+  "am",
+  "was",
+  "were",
+  "do",
+  "does",
+  "did",
+  "can",
+  "could",
+  "should",
+  "would",
+  "will",
+  "shall",
+  "has",
+  "have",
+  "had",
+  "anyone",
+  "any",
+  "may",
+  "might"
+]);
+function normalizeQuestionKey(s) {
+  return s.toLowerCase().replace(/[?.!\s]+$/g, "").replace(/\s+/g, " ").trim();
+}
+function isQuestionSentence(s) {
+  if (s.endsWith("?")) return true;
+  const first = s.replace(/^[^a-zA-Z]+/, "").split(/\s+/)[0]?.toLowerCase() ?? "";
+  return INTERROGATIVE_STARTERS.has(first.replace(/[^a-z]/g, ""));
+}
+function extractQuestions(texts, max = 5) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const text2 of texts) {
+    if (out.length >= max) break;
+    if (!text2) continue;
+    const sentences = text2.split(/(?<=[.!?])\s+|\n+/);
+    for (const raw of sentences) {
+      const s = raw.trim();
+      if (s.length < 8 || s.length > 300) continue;
+      if (!isQuestionSentence(s)) continue;
+      const key = normalizeQuestionKey(s);
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      out.push(s);
+      if (out.length >= max) break;
+    }
+  }
+  return out;
+}
+function trendingTotals(threads) {
+  let upvotes = 0;
+  let comments = 0;
+  for (const t of threads) {
+    upvotes += t.score;
+    comments += t.commentCount;
+  }
+  return { threads: threads.length, upvotes, comments };
+}
+function flattenQuestions(threads) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const t of threads) {
+    for (const q of t.topQuestions) {
+      const key = normalizeQuestionKey(q);
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      out.push({ question: q, threadUrl: t.url });
+    }
+  }
+  return out;
+}
+
+// src/api/reddit-routes.ts
+var RedditThreadBodySchema = z19.object({
+  url: z19.string().trim().min(1, "url is required"),
+  maxComments: z19.number().int().min(1).max(2e3).optional()
+});
+var RedditTrendingBodySchema = z19.object({
+  topic: z19.string().trim().min(1, "topic is required"),
+  subreddit: z19.string().trim().regex(/^(r\/)?[A-Za-z0-9_]{2,24}$/i, "subreddit must be a bare name like SEO").optional(),
+  window: z19.enum(["week", "month"]).default("month"),
+  maxThreads: z19.number().int().min(1).max(40).default(20),
+  includeComments: z19.boolean().default(true),
+  maxCommentsPerThread: z19.number().int().min(1).max(200).default(50)
 });
 function invalidRequest4(message) {
   return { error_code: "invalid_request", message };
@@ -12885,7 +13377,36 @@ var PARSE_REDDIT = `(() => {
   });
   return { title: title, author: author, score: score, postBody: postBody, blocked: blocked, numComments: comments.length, comments: comments };
 })()`;
-var redditApp = new Hono9();
+async function scrapeOldRedditWithRetries(url, script, accept) {
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const backupAttempt = attempt === 3;
+    if (backupAttempt && !backupProxyAvailable()) break;
+    const proxyId = backupAttempt ? await createBackupProxyIdSafe(browserServiceApiKey(), attempt) : await residentialProxyId(attempt);
+    if (backupAttempt && !proxyId) break;
+    const driver = new BrowserDriver();
+    try {
+      await driver.launch({
+        headless: true,
+        headlessMode: "headful",
+        kernelApiKey: browserServiceApiKey(),
+        kernelProxyId: proxyId,
+        viewport: { width: 1280, height: 900 },
+        locale: "en-US"
+      });
+      const page = driver.getPage();
+      await page.goto(url, { waitUntil: "domcontentloaded", timeout: attempt === 0 ? 3e4 : 45e3 });
+      await page.waitForTimeout(2500);
+      const data = await page.evaluate(script);
+      if (accept(data)) return { data, attempts: attempt + 1, proxied: Boolean(proxyId) };
+    } catch {
+    } finally {
+      await driver.close();
+      if (backupAttempt) await cleanupBackupProxyId(browserServiceApiKey(), proxyId);
+    }
+  }
+  return null;
+}
+var redditApp = new Hono10();
 redditApp.post("/thread", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = RedditThreadBodySchema.safeParse(raw);
@@ -12907,29 +13428,13 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
     if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.reddit_thread), 402);
     debited = true;
     let result = null;
-    for (let attempt = 0; attempt < 3 && !result; attempt++) {
-      const proxyId = await residentialProxyId(attempt);
-      const driver = new BrowserDriver();
-      try {
-        await driver.launch({
-          headless: true,
-          headlessMode: "headful",
-          kernelApiKey: browserServiceApiKey(),
-          kernelProxyId: proxyId,
-          viewport: { width: 1280, height: 900 },
-          locale: "en-US"
-        });
-        const page = driver.getPage();
-        await page.goto(oldUrl, { waitUntil: "domcontentloaded", timeout: attempt === 0 ? 3e4 : 45e3 });
-        await page.waitForTimeout(2500);
-        const data = await page.evaluate(PARSE_REDDIT);
-        if (!data.blocked && (data.postBody || data.comments.length > 0)) {
-          result = { ...data, sourceUrl: body.url, oldRedditUrl: oldUrl, attempts: attempt + 1, proxied: Boolean(proxyId) };
-        }
-      } catch {
-      } finally {
-        await driver.close();
-      }
+    const scraped = await scrapeOldRedditWithRetries(
+      oldUrl,
+      PARSE_REDDIT,
+      (data) => !data.blocked && (Boolean(data.postBody) || data.comments.length > 0)
+    );
+    if (scraped) {
+      result = { ...scraped.data, sourceUrl: body.url, oldRedditUrl: oldUrl, attempts: scraped.attempts, proxied: scraped.proxied };
     }
     if (!result) {
       await creditMc(user.id, MC_COSTS.reddit_thread, LedgerOperation.REDDIT_THREAD_REFUND, "reddit blocked/empty after retries");
@@ -12965,17 +13470,152 @@ redditApp.post("/thread", createApiKeyAuth(), async (c) => {
     await releaseConcurrencyGate(gate.lockId);
   }
 });
+var TRENDING_SOFT_DEADLINE_MS = 24e4;
+var TRENDING_SCRAPE_CONCURRENCY = 4;
+redditApp.post("/trending", createApiKeyAuth(), async (c) => {
+  const raw = await c.req.json().catch(() => ({}));
+  const parsed = RedditTrendingBodySchema.safeParse(raw);
+  if (!parsed.success) return c.json(invalidRequest4(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
+  const body = parsed.data;
+  const subreddit = body.subreddit ? body.subreddit.replace(/^r\//i, "") : void 0;
+  const serpQuery = buildSerpQuery(body.topic, subreddit);
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "reddit_trending", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { topic: body.topic }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  const softDeadlineMs = Date.now() + TRENDING_SOFT_DEADLINE_MS;
+  let discoveryDebited = false;
+  let discoveryRefunded = false;
+  const outstanding = { thread: 0, comment: 0 };
+  try {
+    const { ok, balance_mc } = await debitMc(user.id, MC_COSTS.reddit_thread, LedgerOperation.REDDIT_THREAD, serpQuery);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.reddit_thread), 402);
+    discoveryDebited = true;
+    let candidates = [];
+    try {
+      const serp = await harvest({
+        query: serpQuery,
+        serpOnly: true,
+        proxyMode: "none",
+        pages: 2,
+        recency: body.window,
+        kernelApiKey: browserServiceApiKey(),
+        format: "json",
+        outputDir: "/tmp/reddit-trending-serp",
+        softDeadlineMs
+      });
+      candidates = extractRedditThreadUrls(serp.organicResults, body.maxThreads);
+    } catch {
+      candidates = [];
+    }
+    if (candidates.length === 0) {
+      await creditMc(user.id, MC_COSTS.reddit_thread, LedgerOperation.REDDIT_THREAD_REFUND, "no reddit threads discovered");
+      discoveryRefunded = true;
+      await logRequestEvent({ userId: user.id, source: "reddit_trending", status: "failed", query: body.topic, error: "no reddit threads discovered" });
+      return c.json({ error: "No Reddit threads found for that topic and window (refunded)" }, 404);
+    }
+    let ranked;
+    if (!body.includeComments) {
+      ranked = candidates.map((cand) => ({
+        title: cand.title,
+        url: cand.url,
+        subreddit: cand.subreddit,
+        score: 0,
+        commentCount: 0,
+        engagementScore: 0,
+        ageText: "",
+        topQuestions: []
+      }));
+    } else {
+      let balanceExhausted = false;
+      const scrapedThreads = await mapWithConcurrency(candidates, TRENDING_SCRAPE_CONCURRENCY, async (cand) => {
+        if (balanceExhausted || Date.now() >= softDeadlineMs) return null;
+        const oldUrl = toOldReddit(cand.url);
+        if (!oldUrl) return null;
+        const threadDebit = await debitMc(user.id, MC_COSTS.reddit_thread, LedgerOperation.REDDIT_THREAD, cand.url);
+        if (!threadDebit.ok) {
+          balanceExhausted = true;
+          return null;
+        }
+        outstanding.thread += MC_COSTS.reddit_thread;
+        const scraped = await scrapeOldRedditWithRetries(
+          oldUrl,
+          PARSE_REDDIT,
+          (data) => !data.blocked && (Boolean(data.postBody) || data.comments.length > 0)
+        );
+        if (!scraped) {
+          await creditMc(user.id, MC_COSTS.reddit_thread, LedgerOperation.REDDIT_THREAD_REFUND, "reddit blocked/empty after retries");
+          outstanding.thread -= MC_COSTS.reddit_thread;
+          return null;
+        }
+        const score = parseCountText(scraped.data.score);
+        let comments = Array.isArray(scraped.data.comments) ? scraped.data.comments : [];
+        const commentCount = comments.length;
+        comments = comments.slice(0, body.maxCommentsPerThread);
+        let commentMc = comments.length * MC_COSTS.reddit_comment;
+        if (commentMc > 0) {
+          const commentDebit = await debitMc(user.id, commentMc, LedgerOperation.REDDIT_COMMENT, cand.url);
+          if (!commentDebit.ok) {
+            balanceExhausted = true;
+            const affordable = Math.floor((commentDebit.balance_mc ?? 0) / MC_COSTS.reddit_comment);
+            comments = comments.slice(0, affordable);
+            commentMc = affordable * MC_COSTS.reddit_comment;
+            if (commentMc > 0) await debitMc(user.id, commentMc, LedgerOperation.REDDIT_COMMENT, cand.url);
+          }
+          outstanding.comment += commentMc;
+        }
+        const topLevelBodies = comments.filter((cm) => cm && cm.depth === 0).map((cm) => cm.body);
+        return {
+          title: cand.title || scraped.data.title || "",
+          url: cand.url,
+          subreddit: cand.subreddit,
+          score,
+          commentCount,
+          engagementScore: engagementScore(score, commentCount),
+          ageText: "",
+          topQuestions: extractQuestions([scraped.data.postBody, ...topLevelBodies])
+        };
+      });
+      ranked = scrapedThreads.filter((t) => t !== null).sort((a, b) => b.engagementScore - a.engagementScore);
+    }
+    const result = {
+      topic: body.topic,
+      subreddit: subreddit ?? null,
+      window: body.window === "week" ? "7d" : "30d",
+      totals: trendingTotals(ranked),
+      rankedThreads: ranked,
+      questions: flattenQuestions(ranked),
+      threadsScraped: body.includeComments ? ranked.length : 0,
+      candidatesFound: candidates.length,
+      partial: body.includeComments && ranked.length < candidates.length,
+      searchQuery: serpQuery
+    };
+    await logRequestEvent({ userId: user.id, source: "reddit_trending", status: "done", query: body.topic, resultCount: ranked.length, result });
+    return c.json(result);
+  } catch (err) {
+    if (discoveryDebited && !discoveryRefunded) await creditMc(user.id, MC_COSTS.reddit_thread, LedgerOperation.REDDIT_THREAD_REFUND, "failed call");
+    if (outstanding.thread > 0) await creditMc(user.id, outstanding.thread, LedgerOperation.REDDIT_THREAD_REFUND, "failed call");
+    if (outstanding.comment > 0) await creditMc(user.id, outstanding.comment, LedgerOperation.REDDIT_COMMENT_REFUND, "failed call");
+    const msg = err instanceof Error ? err.message : String(err);
+    await logRequestEvent({ userId: user.id, source: "reddit_trending", status: "failed", query: body.topic, error: msg });
+    return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
+  }
+});
 
 // src/api/video-routes.ts
-import { Hono as Hono10 } from "hono";
-import { z as z19 } from "zod";
-var videoApp = new Hono10();
-var AnalyzeBodySchema = z19.object({
-  sourceUrl: z19.string().trim().url("sourceUrl must be a direct video file URL"),
-  intervalS: z19.number().min(1).max(30).optional(),
-  maxFrames: z19.number().int().min(1).max(480).optional(),
-  detail: z19.enum(["fast", "standard", "deep"]).optional(),
-  vault: z19.string().trim().min(1).optional()
+import { Hono as Hono11 } from "hono";
+import { z as z20 } from "zod";
+var videoApp = new Hono11();
+var AnalyzeBodySchema = z20.object({
+  sourceUrl: z20.string().trim().url("sourceUrl must be a direct video file URL"),
+  intervalS: z20.number().min(1).max(30).optional(),
+  maxFrames: z20.number().int().min(1).max(480).optional(),
+  detail: z20.enum(["fast", "standard", "deep"]).optional(),
+  vault: z20.string().trim().min(1).optional()
 });
 function invalidRequest5(message) {
   return { error_code: "invalid_request", message };
@@ -13079,7 +13719,7 @@ videoApp.post("/status", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/maps-routes.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 
 // src/extractor/GoogleBusinessPanel.ts
 function clickNamedBusinessCardInBrowser(businessName) {
@@ -13805,7 +14445,7 @@ var MapsReviewCollector = class {
 };
 
 // src/extractor/MapsExtractor.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var MapsExtractor = class {
   constructor(driver) {
     this.driver = driver;
@@ -14032,7 +14672,7 @@ var MapsExtractor = class {
       });
       return rows;
     }, { hoursTable: MapsSelectors.hoursTable, hoursTableAlt: MapsSelectors.hoursTableAlt });
-    const result = z20.array(RawMapsHoursRowSchema).safeParse(raw);
+    const result = z21.array(RawMapsHoursRowSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] hours parse failed", result.error.flatten());
       return [];
@@ -14096,7 +14736,7 @@ var MapsExtractor = class {
       });
       return results;
     });
-    const result = z20.array(RawMapsAboutAttributeSchema).safeParse(raw);
+    const result = z21.array(RawMapsAboutAttributeSchema).safeParse(raw);
     if (!result.success) {
       console.warn("[MapsExtractor] about parse failed", result.error.flatten());
       return [];
@@ -14197,7 +14837,8 @@ async function cleanupDisposableProxy(kernelApiKey, proxyId, eventName) {
 async function runMapsSearchWithRotation(options) {
   if (options.proxyMode === "location") options = { ...options, proxyMode: "none" };
   const attempts = [];
-  const maxAttempts = mapsSearchMaxAttemptsForProxyMode(options.proxyMode) + 1;
+  const baseMaxAttempts = mapsSearchMaxAttemptsForProxyMode(options.proxyMode) + 1;
+  const maxAttempts = baseMaxAttempts + (backupProxyAvailable() ? BACKUP_LAST_RESORT_ATTEMPTS : 0);
   const started = Date.now();
   let lastError = null;
   for (let attemptIndex = 0; attemptIndex < maxAttempts; attemptIndex += 1) {
@@ -14207,8 +14848,13 @@ async function runMapsSearchWithRotation(options) {
     const proxyZip = options.proxyZipForAttempt?.(attemptIndex) ?? options.proxyZip;
     let resolution = null;
     let disposableProxyId;
+    const isBackupAttempt = attemptIndex >= baseMaxAttempts;
     try {
-      resolution = await resolveKernelProxyId({
+      resolution = isBackupAttempt ? await resolveBackupKernelProxyId({
+        kernelApiKey: options.kernelApiKey,
+        proxyMode: options.proxyMode,
+        attemptIndex
+      }) : await resolveKernelProxyId({
         kernelApiKey: options.kernelApiKey,
         proxyMode: options.proxyMode,
         configuredKernelProxyId: options.kernelProxyId ?? options.configuredKernelProxyId,
@@ -14216,18 +14862,20 @@ async function runMapsSearchWithRotation(options) {
         proxyZip,
         gl: options.gl,
         attemptIndex,
-        fresh: options.proxyMode === "location"
+        fresh: options.proxyMode === "location",
+        backupOnExhaustion: true
       });
+      if (!resolution) break;
       disposableProxyId = resolution.disposableProxyId;
       const extractArgs = {
         ...options,
         proxyZip,
-        kernelProxyId: options.proxyMode === "none" ? void 0 : resolution.kernelProxyId,
+        kernelProxyId: options.proxyMode === "none" && !isBackupAttempt ? void 0 : resolution.kernelProxyId,
         kernelProxyResolution: resolution.resolution,
-        serpRedirect: options.proxyMode === "none" && attemptIndex >= 2 && attemptIndex < 6,
-        forceDirectEgress: options.proxyMode === "none" && attemptIndex >= 4
+        serpRedirect: options.proxyMode === "none" && !isBackupAttempt && attemptIndex >= 2 && attemptIndex < 6,
+        forceDirectEgress: options.proxyMode === "none" && !isBackupAttempt && attemptIndex >= 4
       };
-      const isHeadfulEscalation = attemptIndex === maxAttempts - 1;
+      const isHeadfulEscalation = attemptIndex >= baseMaxAttempts - 1;
       const baseCtx = currentCostContext();
       const result = isHeadfulEscalation && baseCtx ? await runWithCostContext({ ...baseCtx, forceHeadful: true }, () => extractor.extract(extractArgs)) : await extractor.extract(extractArgs);
       const attempt = attemptFromDebug({
@@ -14314,7 +14962,7 @@ function mapsErrorResponse(c, err, errorCode) {
     attempts: rotationError?.attempts ?? void 0
   }, retryable ? 503 : 500);
 }
-var mapsApp = new Hono11();
+var mapsApp = new Hono12();
 mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -14452,11 +15100,11 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/trustpilot-routes.ts
-import { Hono as Hono12 } from "hono";
-import { z as z21 } from "zod";
-var TrustpilotReviewsBodySchema = z21.object({
-  domain: z21.string().trim().min(1, "domain is required"),
-  maxPages: z21.number().int().min(1).max(50).default(5)
+import { Hono as Hono13 } from "hono";
+import { z as z22 } from "zod";
+var TrustpilotReviewsBodySchema = z22.object({
+  domain: z22.string().trim().min(1, "domain is required"),
+  maxPages: z22.number().int().min(1).max(50).default(5)
 });
 function invalidRequest6(message) {
   return { error_code: "invalid_request", message };
@@ -14521,7 +15169,7 @@ async function extractReviewCards(page) {
     });
   });
 }
-var trustpilotApp = new Hono12();
+var trustpilotApp = new Hono13();
 trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = TrustpilotReviewsBodySchema.safeParse(raw);
@@ -14602,11 +15250,11 @@ trustpilotApp.post("/reviews", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/g2-routes.ts
-import { Hono as Hono13 } from "hono";
-import { z as z22 } from "zod";
-var G2ReviewsBodySchema = z22.object({
-  product: z22.string().trim().min(1, "product is required"),
-  maxPages: z22.number().int().min(1).max(50).default(5)
+import { Hono as Hono14 } from "hono";
+import { z as z23 } from "zod";
+var G2ReviewsBodySchema = z23.object({
+  product: z23.string().trim().min(1, "product is required"),
+  maxPages: z23.number().int().min(1).max(50).default(5)
 });
 function invalidRequest7(message) {
   return { error_code: "invalid_request", message };
@@ -14711,7 +15359,7 @@ async function extractG2ReviewCards(page) {
     });
   });
 }
-var g2App = new Hono13();
+var g2App = new Hono14();
 g2App.post("/reviews", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = G2ReviewsBodySchema.safeParse(raw);
@@ -14734,8 +15382,11 @@ g2App.post("/reviews", createApiKeyAuth(), async (c) => {
     const allReviews = [];
     let pagesFetched = 0;
     let blocked = false;
-    for (let attempt = 0; attempt < 3 && pagesFetched === 0; attempt++) {
-      const proxyId = await residentialProxyId2(attempt);
+    for (let attempt = 0; attempt < 4 && pagesFetched === 0; attempt++) {
+      const backupAttempt = attempt === 3;
+      if (backupAttempt && !backupProxyAvailable()) break;
+      const proxyId = backupAttempt ? await createBackupProxyIdSafe(browserServiceApiKey(), attempt) : await residentialProxyId2(attempt);
+      if (backupAttempt && !proxyId) break;
       const driver = new BrowserDriver();
       try {
         await driver.launch({
@@ -14768,6 +15419,7 @@ g2App.post("/reviews", createApiKeyAuth(), async (c) => {
         blocked = true;
       } finally {
         await driver.close();
+        if (backupAttempt) await cleanupBackupProxyId(browserServiceApiKey(), proxyId);
       }
     }
     if (pagesFetched === 0 || allReviews.length === 0) {
@@ -14808,12 +15460,12 @@ g2App.post("/reviews", createApiKeyAuth(), async (c) => {
 });
 
 // src/api/directory-routes.ts
-import { Hono as Hono14 } from "hono";
+import { Hono as Hono15 } from "hono";
 
 // src/directory/directory-workflow.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { join as join4 } from "path";
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/directory/location-db.ts
 import { access, readFile } from "fs/promises";
@@ -14974,24 +15626,24 @@ async function resolveDirectoryMarkets(options) {
 }
 
 // src/directory/directory-workflow.ts
-var DirectoryWorkflowOptionsSchema = z23.object({
-  query: z23.string().min(1),
-  state: z23.string().min(2).default("TN"),
-  minPopulation: z23.number().int().min(0).default(1e5),
-  populationYear: z23.union(POPULATION_YEARS.map((year) => z23.literal(year))).default(2025),
-  maxCities: z23.number().int().min(1).max(100).default(25),
-  maxResultsPerCity: z23.number().int().min(1).max(50).default(50),
-  concurrency: z23.number().int().min(1).max(5).default(5),
-  includeZipGroups: z23.boolean().default(true),
-  usZipsCsvPath: z23.string().optional(),
-  saveCsv: z23.boolean().default(true),
-  gl: z23.string().length(2).default("us"),
-  hl: z23.string().length(2).default("en"),
-  proxyMode: z23.enum(["configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
-  proxyZip: z23.string().regex(/^\d{5}$/).optional(),
-  debug: z23.boolean().default(false),
-  headless: z23.boolean().default(true),
-  kernelApiKey: z23.string().optional()
+var DirectoryWorkflowOptionsSchema = z24.object({
+  query: z24.string().min(1),
+  state: z24.string().min(2).default("TN"),
+  minPopulation: z24.number().int().min(0).default(1e5),
+  populationYear: z24.union(POPULATION_YEARS.map((year) => z24.literal(year))).default(2025),
+  maxCities: z24.number().int().min(1).max(100).default(25),
+  maxResultsPerCity: z24.number().int().min(1).max(50).default(50),
+  concurrency: z24.number().int().min(1).max(5).default(5),
+  includeZipGroups: z24.boolean().default(true),
+  usZipsCsvPath: z24.string().optional(),
+  saveCsv: z24.boolean().default(true),
+  gl: z24.string().length(2).default("us"),
+  hl: z24.string().length(2).default("en"),
+  proxyMode: z24.enum(["configured", "none"]).default(DEFAULT_MAPS_PROXY_MODE),
+  proxyZip: z24.string().regex(/^\d{5}$/).optional(),
+  debug: z24.boolean().default(false),
+  headless: z24.boolean().default(true),
+  kernelApiKey: z24.string().optional()
 });
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -15213,7 +15865,7 @@ async function runDirectoryWorkflowFromPlan(options, plan) {
 }
 
 // src/api/directory-routes.ts
-var directoryApp = new Hono14();
+var directoryApp = new Hono15();
 directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const body = await c.req.json().catch(() => ({}));
@@ -15286,35 +15938,35 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
 // src/api/workflow-routes.ts
 import { createHmac as createHmac3 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { Hono as Hono15 } from "hono";
-import { z as z24 } from "zod";
-var workflowApp = new Hono15();
-var WorkflowInputSchema = z24.record(z24.unknown()).default({});
-var WorkflowIdSchema = z24.string().min(1);
-var CadenceSchema = z24.enum(["daily", "weekly", "monthly"]);
-var ScheduleStatusSchema = z24.enum(["active", "paused"]);
-var RunBodySchema = z24.object({
+import { Hono as Hono16 } from "hono";
+import { z as z25 } from "zod";
+var workflowApp = new Hono16();
+var WorkflowInputSchema = z25.record(z25.unknown()).default({});
+var WorkflowIdSchema = z25.string().min(1);
+var CadenceSchema = z25.enum(["daily", "weekly", "monthly"]);
+var ScheduleStatusSchema = z25.enum(["active", "paused"]);
+var RunBodySchema = z25.object({
   workflowId: WorkflowIdSchema,
   input: WorkflowInputSchema,
-  webhookUrl: z24.string().url().optional()
+  webhookUrl: z25.string().url().optional()
 });
-var ScheduleCreateSchema = z24.object({
+var ScheduleCreateSchema = z25.object({
   workflowId: WorkflowIdSchema,
-  name: z24.string().min(1).max(120).optional(),
+  name: z25.string().min(1).max(120).optional(),
   input: WorkflowInputSchema,
   cadence: CadenceSchema.default("weekly"),
-  timezone: z24.string().min(1).max(64).default("UTC"),
-  webhookUrl: z24.string().url().optional(),
-  nextRunAt: z24.string().datetime().optional()
+  timezone: z25.string().min(1).max(64).default("UTC"),
+  webhookUrl: z25.string().url().optional(),
+  nextRunAt: z25.string().datetime().optional()
 });
-var SchedulePatchSchema = z24.object({
-  name: z24.string().min(1).max(120).optional(),
+var SchedulePatchSchema = z25.object({
+  name: z25.string().min(1).max(120).optional(),
   status: ScheduleStatusSchema.optional(),
   input: WorkflowInputSchema.optional(),
   cadence: CadenceSchema.optional(),
-  timezone: z24.string().min(1).max(64).optional(),
-  webhookUrl: z24.string().url().nullable().optional(),
-  nextRunAt: z24.string().datetime().nullable().optional()
+  timezone: z25.string().min(1).max(64).optional(),
+  webhookUrl: z25.string().url().nullable().optional(),
+  nextRunAt: z25.string().datetime().nullable().optional()
 });
 function hostedWorkflowOutputDir() {
   return workflowOutputBaseDir(process.env.MCP_SCRAPER_WORKFLOW_OUTPUT_DIR?.trim() || "/tmp/mcp-scraper-workflows");
@@ -15818,7 +16470,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 });
 
 // src/api/serp-intelligence-routes.ts
-import { Hono as Hono16 } from "hono";
+import { Hono as Hono17 } from "hono";
 import { createHash as createHash5, randomUUID as randomUUID4 } from "crypto";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
@@ -16131,7 +16783,7 @@ async function capturePageSnapshots(targets, options = {}) {
 }
 
 // src/serp-intelligence/schemas.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var SerpIntelligenceDeviceValues = ["desktop", "mobile"];
 var SerpIntelligenceProxyModeValues = ["location", "configured", "none"];
 var SerpIntelligenceAttemptOutcomeValues = [
@@ -16193,181 +16845,181 @@ function isPublicHttpUrl(value) {
     return false;
   }
 }
-var SerpIntelligencePublicHttpUrlSchema = z25.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
-var SerpIntelligenceCaptureBodySchema = z25.object({
-  query: z25.string().trim().min(1, "query is required"),
-  location: z25.string().trim().min(1).optional(),
-  gl: z25.string().trim().length(2).default("us"),
-  hl: z25.string().trim().length(2).default("en"),
-  device: z25.enum(SerpIntelligenceDeviceValues).default("desktop"),
-  proxyMode: z25.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
-  proxyZip: z25.string().regex(/^\d{5}$/).optional(),
-  pages: z25.number().int().min(1).max(2).default(1),
-  debug: z25.boolean().default(false),
-  includePageSnapshots: z25.boolean().default(false),
-  pageSnapshotLimit: z25.number().int().min(0).max(10).default(0)
+var SerpIntelligencePublicHttpUrlSchema = z26.string().url().refine(isPublicHttpUrl, "url must be a public HTTP or HTTPS URL");
+var SerpIntelligenceCaptureBodySchema = z26.object({
+  query: z26.string().trim().min(1, "query is required"),
+  location: z26.string().trim().min(1).optional(),
+  gl: z26.string().trim().length(2).default("us"),
+  hl: z26.string().trim().length(2).default("en"),
+  device: z26.enum(SerpIntelligenceDeviceValues).default("desktop"),
+  proxyMode: z26.enum(SerpIntelligenceProxyModeValues).default(DEFAULT_PROXY_MODE),
+  proxyZip: z26.string().regex(/^\d{5}$/).optional(),
+  pages: z26.number().int().min(1).max(2).default(1),
+  debug: z26.boolean().default(false),
+  includePageSnapshots: z26.boolean().default(false),
+  pageSnapshotLimit: z26.number().int().min(0).max(10).default(0)
 }).strict();
-var SerpIntelligencePageSnapshotRequestSchema = z25.object({
+var SerpIntelligencePageSnapshotRequestSchema = z26.object({
   url: SerpIntelligencePublicHttpUrlSchema,
-  sourceKind: z25.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
-  sourcePosition: z25.number().int().min(1).optional()
+  sourceKind: z26.enum(SerpPageSnapshotSourceKindValues).default("configured_target"),
+  sourcePosition: z26.number().int().min(1).optional()
 }).strict();
-var SerpIntelligencePageSnapshotsBodySchema = z25.object({
-  urls: z25.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25).optional(),
-  targets: z25.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
-  maxConcurrency: z25.number().int().min(1).max(5).default(2),
-  timeoutMs: z25.number().int().min(1e3).max(6e4).default(15e3),
-  debug: z25.boolean().default(false)
+var SerpIntelligencePageSnapshotsBodySchema = z26.object({
+  urls: z26.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25).optional(),
+  targets: z26.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
+  maxConcurrency: z26.number().int().min(1).max(5).default(2),
+  timeoutMs: z26.number().int().min(1e3).max(6e4).default(15e3),
+  debug: z26.boolean().default(false)
 }).strict().superRefine((body, ctx) => {
   const hasUrls = Boolean(body.urls?.length);
   const hasTargets = Boolean(body.targets?.length);
   if (hasUrls === hasTargets) {
     ctx.addIssue({
-      code: z25.ZodIssueCode.custom,
+      code: z26.ZodIssueCode.custom,
       message: "provide exactly one of urls or targets",
       path: hasUrls ? ["targets"] : ["urls"]
     });
   }
 });
-var SerpIntelligenceAICitationSchema = z25.object({
-  text: z25.string(),
-  href: z25.string()
+var SerpIntelligenceAICitationSchema = z26.object({
+  text: z26.string(),
+  href: z26.string()
 }).strict();
-var SerpIntelligenceOrganicResultSchema = z25.object({
-  position: z25.number().int().min(1),
-  title: z25.string(),
-  url: z25.string(),
-  domain: z25.string(),
-  cite: z25.string().nullable(),
-  snippet: z25.string().nullable(),
-  isRedditStyle: z25.boolean(),
-  inlineRating: z25.object({
-    value: z25.string(),
-    count: z25.string()
+var SerpIntelligenceOrganicResultSchema = z26.object({
+  position: z26.number().int().min(1),
+  title: z26.string(),
+  url: z26.string(),
+  domain: z26.string(),
+  cite: z26.string().nullable(),
+  snippet: z26.string().nullable(),
+  isRedditStyle: z26.boolean(),
+  inlineRating: z26.object({
+    value: z26.string(),
+    count: z26.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceLocationEvidenceSchema = z25.object({
-  status: z25.enum(SerpIntelligenceLocalizationStatusValues),
-  expected: z25.object({
-    city: z25.string(),
-    regionCode: z25.string().nullable(),
-    canonicalLocation: z25.string()
+var SerpIntelligenceLocationEvidenceSchema = z26.object({
+  status: z26.enum(SerpIntelligenceLocalizationStatusValues),
+  expected: z26.object({
+    city: z26.string(),
+    regionCode: z26.string().nullable(),
+    canonicalLocation: z26.string()
   }).strict().nullable(),
-  candidates: z25.array(z25.object({
-    city: z25.string(),
-    regionCode: z25.string(),
-    count: z25.number().int().min(0),
-    examples: z25.array(z25.string())
+  candidates: z26.array(z26.object({
+    city: z26.string(),
+    regionCode: z26.string(),
+    count: z26.number().int().min(0),
+    examples: z26.array(z26.string())
   }).strict())
 }).strict();
-var SerpIntelligenceHarvestResultSchema = z25.object({
-  seed: z25.string(),
-  location: z25.string().nullable(),
-  extractedAt: z25.string(),
-  totalQuestions: z25.number().int().min(0),
-  surface: z25.enum(["web", "aim", "unknown"]),
-  aiOverview: z25.object({
-    detected: z25.boolean(),
-    text: z25.string().nullable(),
-    citations: z25.array(SerpIntelligenceAICitationSchema),
-    expanded: z25.boolean().optional(),
-    fullyExpanded: z25.boolean().optional(),
-    sections: z25.array(z25.string()).optional()
+var SerpIntelligenceHarvestResultSchema = z26.object({
+  seed: z26.string(),
+  location: z26.string().nullable(),
+  extractedAt: z26.string(),
+  totalQuestions: z26.number().int().min(0),
+  surface: z26.enum(["web", "aim", "unknown"]),
+  aiOverview: z26.object({
+    detected: z26.boolean(),
+    text: z26.string().nullable(),
+    citations: z26.array(SerpIntelligenceAICitationSchema),
+    expanded: z26.boolean().optional(),
+    fullyExpanded: z26.boolean().optional(),
+    sections: z26.array(z26.string()).optional()
   }).strict(),
-  aiMode: z25.object({
-    detected: z25.boolean(),
-    text: z25.string().nullable(),
-    citations: z25.array(SerpIntelligenceAICitationSchema)
+  aiMode: z26.object({
+    detected: z26.boolean(),
+    text: z26.string().nullable(),
+    citations: z26.array(SerpIntelligenceAICitationSchema)
   }).strict(),
-  tree: z25.array(z25.unknown()),
-  flat: z25.array(z25.unknown()),
-  videos: z25.array(z25.unknown()),
-  forums: z25.array(z25.unknown()),
-  organicResults: z25.array(SerpIntelligenceOrganicResultSchema),
-  localPack: z25.array(z25.unknown()),
-  entityIds: z25.object({
-    entities: z25.array(z25.object({
-      name: z25.string(),
-      kgId: z25.string().nullable(),
-      cid: z25.string().nullable(),
-      gcid: z25.string().nullable()
+  tree: z26.array(z26.unknown()),
+  flat: z26.array(z26.unknown()),
+  videos: z26.array(z26.unknown()),
+  forums: z26.array(z26.unknown()),
+  organicResults: z26.array(SerpIntelligenceOrganicResultSchema),
+  localPack: z26.array(z26.unknown()),
+  entityIds: z26.object({
+    entities: z26.array(z26.object({
+      name: z26.string(),
+      kgId: z26.string().nullable(),
+      cid: z26.string().nullable(),
+      gcid: z26.string().nullable()
     }).strict()),
-    kgIds: z25.array(z25.string()),
-    cids: z25.array(z25.string()),
-    gcids: z25.array(z25.string())
+    kgIds: z26.array(z26.string()),
+    cids: z26.array(z26.string()),
+    gcids: z26.array(z26.string())
   }).strict(),
-  stats: z25.object({
-    seed: z25.string(),
-    totalQuestions: z25.number().int().min(0),
-    maxDepthReached: z25.number().int().min(0),
-    durationMs: z25.number().min(0),
-    errorCount: z25.number().int().min(0)
+  stats: z26.object({
+    seed: z26.string(),
+    totalQuestions: z26.number().int().min(0),
+    maxDepthReached: z26.number().int().min(0),
+    durationMs: z26.number().min(0),
+    errorCount: z26.number().int().min(0)
   }).strict(),
-  diagnostics: z25.object({
-    completionStatus: z25.enum(["paa_found", "no_paa", "serp_only"]),
-    problem: z25.null(),
-    warnings: z25.array(z25.unknown()).optional(),
-    debug: z25.object({
+  diagnostics: z26.object({
+    completionStatus: z26.enum(["paa_found", "no_paa", "serp_only"]),
+    problem: z26.null(),
+    warnings: z26.array(z26.unknown()).optional(),
+    debug: z26.object({
       locationEvidence: SerpIntelligenceLocationEvidenceSchema.optional()
     }).passthrough().optional()
   }).passthrough(),
-  whatPeopleSaying: z25.array(z25.unknown())
+  whatPeopleSaying: z26.array(z26.unknown())
 }).strict();
-var SerpIntelligenceCaptureAttemptSchema = z25.object({
-  attemptNumber: z25.number().int().min(1),
-  outcome: z25.enum(SerpIntelligenceAttemptOutcomeValues),
-  startedAt: z25.string().optional(),
-  completedAt: z25.string().optional(),
-  durationMs: z25.number().min(0).optional(),
-  problemCode: z25.string().optional(),
-  message: z25.string().optional(),
-  kernelSessionId: z25.string().nullable().optional(),
-  cleanupSucceeded: z25.boolean().nullable().optional()
+var SerpIntelligenceCaptureAttemptSchema = z26.object({
+  attemptNumber: z26.number().int().min(1),
+  outcome: z26.enum(SerpIntelligenceAttemptOutcomeValues),
+  startedAt: z26.string().optional(),
+  completedAt: z26.string().optional(),
+  durationMs: z26.number().min(0).optional(),
+  problemCode: z26.string().optional(),
+  message: z26.string().optional(),
+  kernelSessionId: z26.string().nullable().optional(),
+  cleanupSucceeded: z26.boolean().nullable().optional()
 }).strict();
-var SerpPageSnapshotCaptureSchema = z25.object({
+var SerpPageSnapshotCaptureSchema = z26.object({
   url: SerpIntelligencePublicHttpUrlSchema,
   requestedUrl: SerpIntelligencePublicHttpUrlSchema,
   finalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  sourceKind: z25.enum(SerpPageSnapshotSourceKindValues),
-  sourcePosition: z25.number().int().min(1).nullable(),
-  status: z25.enum(SerpPageFetchStatusValues),
-  fetchedVia: z25.enum(SerpPageFetchedViaValues).nullable(),
-  httpStatus: z25.number().int().min(100).max(599).nullable(),
-  contentType: z25.string().nullable(),
-  title: z25.string().nullable(),
+  sourceKind: z26.enum(SerpPageSnapshotSourceKindValues),
+  sourcePosition: z26.number().int().min(1).nullable(),
+  status: z26.enum(SerpPageFetchStatusValues),
+  fetchedVia: z26.enum(SerpPageFetchedViaValues).nullable(),
+  httpStatus: z26.number().int().min(100).max(599).nullable(),
+  contentType: z26.string().nullable(),
+  title: z26.string().nullable(),
   canonicalUrl: SerpIntelligencePublicHttpUrlSchema.nullable(),
-  metaDescription: z25.string().nullable(),
-  headings: z25.array(z25.object({
-    level: z25.number().int().min(1).max(6),
-    text: z25.string()
+  metaDescription: z26.string().nullable(),
+  headings: z26.array(z26.object({
+    level: z26.number().int().min(1).max(6),
+    text: z26.string()
   }).strict()).default([]),
-  artifact: z25.object({
-    htmlBlobUrl: z25.string().url().nullable(),
-    textBlobUrl: z25.string().url().nullable(),
-    markdownBlobUrl: z25.string().url().nullable(),
-    screenshotBlobUrl: z25.string().url().nullable(),
-    contentSha256: z25.string().nullable(),
-    capturedAt: z25.string().nullable()
+  artifact: z26.object({
+    htmlBlobUrl: z26.string().url().nullable(),
+    textBlobUrl: z26.string().url().nullable(),
+    markdownBlobUrl: z26.string().url().nullable(),
+    screenshotBlobUrl: z26.string().url().nullable(),
+    contentSha256: z26.string().nullable(),
+    capturedAt: z26.string().nullable()
   }).strict(),
-  error: z25.object({
-    code: z25.string(),
-    message: z25.string()
+  error: z26.object({
+    code: z26.string(),
+    message: z26.string()
   }).strict().nullable()
 }).strict();
-var SerpIntelligenceCaptureResponseSchema = z25.object({
+var SerpIntelligenceCaptureResponseSchema = z26.object({
   harvestResult: SerpIntelligenceHarvestResultSchema,
-  attempts: z25.array(SerpIntelligenceCaptureAttemptSchema),
+  attempts: z26.array(SerpIntelligenceCaptureAttemptSchema),
   locationEvidence: SerpIntelligenceLocationEvidenceSchema.nullable(),
-  pageSnapshotArtifacts: z25.array(SerpPageSnapshotCaptureSchema),
-  billing: z25.object({
-    creditsUsed: z25.number().min(0).optional(),
-    requestId: z25.string().optional(),
-    jobId: z25.string().optional()
+  pageSnapshotArtifacts: z26.array(SerpPageSnapshotCaptureSchema),
+  billing: z26.object({
+    creditsUsed: z26.number().min(0).optional(),
+    requestId: z26.string().optional(),
+    jobId: z26.string().optional()
   }).strict().optional()
 }).strict();
-var SerpIntelligencePageSnapshotsResponseSchema = z25.object({
-  pageSnapshotArtifacts: z25.array(SerpPageSnapshotCaptureSchema),
-  attempts: z25.array(SerpIntelligenceCaptureAttemptSchema).default([])
+var SerpIntelligencePageSnapshotsResponseSchema = z26.object({
+  pageSnapshotArtifacts: z26.array(SerpPageSnapshotCaptureSchema),
+  attempts: z26.array(SerpIntelligenceCaptureAttemptSchema).default([])
 }).strict();
 
 // src/serp-intelligence/serp-capture-service.ts
@@ -16550,7 +17202,7 @@ var SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
 var POST_CAPTURE_ROUTE_LABEL = "POST /capture";
 var POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
 var SERP_CAPTURE_BILLING_SOURCE = "serp_intelligence_capture";
-var serpIntelligenceApp = new Hono16();
+var serpIntelligenceApp = new Hono17();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
   return {
@@ -16826,7 +17478,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
 });
 
 // src/mcp/mcp-routes.ts
-import { Hono as Hono17 } from "hono";
+import { Hono as Hono18 } from "hono";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 
 // src/mcp/memory-mcp-tool-executor.ts
@@ -17477,7 +18129,7 @@ async function requireMcpCallerKey(c) {
   if (!user) return mcpAuthError();
   return { key: callerKey, user };
 }
-var mcpApp = new Hono17();
+var mcpApp = new Hono18();
 mcpApp.all("/", async (c) => {
   try {
     const keyOrError = await requireMcpCallerKey(c);
@@ -17504,7 +18156,7 @@ mcpApp.all("/", async (c) => {
 
 // src/api/browser-agent-routes.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { Hono as Hono18 } from "hono";
+import { Hono as Hono19 } from "hono";
 
 // src/api/browser-agent-db.ts
 import { randomUUID as randomUUID5 } from "crypto";
@@ -17705,6 +18357,57 @@ async function listAuthConnectionsByProfile(profile) {
   });
   return res.rows;
 }
+async function listProfileSummaries(userId) {
+  const db = getDb();
+  const res = await db.execute({
+    sql: `SELECT c.profile AS profile,
+                 l.label AS label,
+                 COUNT(DISTINCT c.domain) AS domains,
+                 MAX(COALESCE(c.updated_at, c.created_at)) AS last_used_at
+          FROM browser_auth_connections c
+          JOIN browser_agent_sessions s ON s.id = c.browser_agent_session_id
+          LEFT JOIN browser_profile_labels l ON l.user_id = s.user_id AND l.profile = c.profile
+          WHERE s.user_id = ? AND c.profile IS NOT NULL
+          GROUP BY c.profile, l.label
+          ORDER BY MAX(COALESCE(c.updated_at, c.created_at)) DESC`,
+    args: [userId]
+  });
+  return res.rows.map((row) => ({
+    profile: String(row.profile),
+    label: row.label == null ? null : String(row.label),
+    domains: Number(row.domains ?? 0),
+    last_used_at: row.last_used_at == null ? null : String(row.last_used_at)
+  }));
+}
+async function userHasProfile(userId, profile) {
+  if (!profile) return false;
+  const db = getDb();
+  const res = await db.execute({
+    sql: `SELECT 1 AS present
+          FROM browser_auth_connections c
+          JOIN browser_agent_sessions s ON s.id = c.browser_agent_session_id
+          WHERE s.user_id = ? AND c.profile = ?
+          LIMIT 1`,
+    args: [userId, profile]
+  });
+  return res.rows.length > 0;
+}
+async function upsertProfileLabel(userId, profile, label) {
+  const db = getDb();
+  await db.execute({
+    sql: `INSERT INTO browser_profile_labels (user_id, profile, label)
+          VALUES (?, ?, ?)
+          ON CONFLICT(user_id, profile) DO UPDATE SET label = excluded.label, updated_at = datetime('now')`,
+    args: [userId, profile, label]
+  });
+}
+async function deleteProfileLabel(userId, profile) {
+  const db = getDb();
+  await db.execute({
+    sql: `DELETE FROM browser_profile_labels WHERE user_id = ? AND profile = ?`,
+    args: [userId, profile]
+  });
+}
 async function createSessionRow(input) {
   const db = getDb();
   const id = `bas_${randomUUID5().replace(/-/g, "").slice(0, 20)}`;
@@ -19006,12 +19709,55 @@ async function loadOpenSession(id, userId) {
   return row;
 }
 function buildBrowserAgentRoutes() {
-  const app2 = new Hono18();
+  const app2 = new Hono19();
   app2.use("*", async (c, next) => {
     await migrateBrowserAgent();
     return next();
   });
   app2.use("*", auth);
+  app2.get("/profiles", async (c) => {
+    const user = c.get("user");
+    try {
+      const rows = await listProfileSummaries(user.id);
+      return c.json({
+        ok: true,
+        profiles: rows.map((row) => ({
+          profile: row.profile,
+          label: row.label,
+          domains: row.domains,
+          last_used_at: row.last_used_at
+        }))
+      });
+    } catch (err) {
+      return c.json(failure(err), 502);
+    }
+  });
+  app2.patch("/profiles/label", async (c) => {
+    const user = c.get("user");
+    const body = await c.req.json().catch(() => ({}));
+    const profileName = typeof body.profile === "string" ? body.profile.trim() : "";
+    if (!profileName) return c.json({ error: "profile is required" }, 400);
+    const rawLabel = body.label;
+    if (rawLabel !== null && typeof rawLabel !== "string") {
+      return c.json({ error: "label must be a string of 1-60 characters, or null to clear the display label" }, 400);
+    }
+    const label = typeof rawLabel === "string" ? rawLabel.trim() : null;
+    if (rawLabel !== null && (!label || label.length > 60)) {
+      return c.json({ error: "label must be a string of 1-60 characters, or null to clear the display label" }, 400);
+    }
+    try {
+      const owned = await userHasProfile(user.id, profileName);
+      if (!owned) return c.json({ error: "profile not found" }, 404);
+      if (label == null) {
+        await deleteProfileLabel(user.id, profileName);
+      } else {
+        await upsertProfileLabel(user.id, profileName, label);
+      }
+      return c.json({ ok: true, profile: profileName, profile_name_immutable: true, label });
+    } catch (err) {
+      return c.json(failure(err), 502);
+    }
+  });
   app2.post("/profiles/onboard", async (c) => {
     const user = c.get("user");
     if (Number(user.balance_mc ?? 0) < BROWSER_OPEN_MIN_BALANCE_MC) {
@@ -19682,320 +20428,123 @@ async function selectSession(id) {
 async function openSession() {
   const r = await api('POST', '/sessions', { label: 'console', disable_default_proxy: true });
   if (r.ok) { await refreshSessions(); selectSession(r.data.session_id); }
-  else alert('Open failed: ' + JSON.stringify(r.data));
-}
-
-async function closeCurrent() {
-  if (!state.current) return;
-  await api('DELETE', '/sessions/' + state.current);
-  await refreshSessions();
-}
-
-async function downloadReplay(replayId) {
-  if (!state.current || !replayId) return;
-  const res = await fetch('/agent/sessions/' + encodeURIComponent(state.current) + '/replays/' + encodeURIComponent(replayId) + '/download', {
-    headers: { 'x-api-key': state.key },
-  });
-  if (!res.ok) {
-    alert('Replay download failed: ' + await res.text());
-    return;
-  }
-  const blob = await res.blob();
-  const url = URL.createObjectURL(blob);
-  const a = document.createElement('a');
-  a.href = url;
-  a.download = state.current + '-' + replayId + '.mp4';
-  document.body.appendChild(a);
-  a.click();
-  a.remove();
-  URL.revokeObjectURL(url);
-}
-
-function frameSrc() {
-  if (!state.liveUrl) return null;
-  const sep = state.liveUrl.includes('?') ? '&' : '?';
-  return state.readOnly ? state.liveUrl + sep + 'readOnly=true' : state.liveUrl;
-}
-
-function saveKey(v) { state.key = v.trim(); localStorage.setItem(KEY_STORE, state.key); render(); if (state.key) { refreshSessions(); if (state.current) selectSession(state.current); } }
-
-function h(html) { const t = document.createElement('template'); t.innerHTML = html.trim(); return t.content.firstChild; }
-function esc(s) { return String(s == null ? '' : s).replace(/[&<>"]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c])); }
-
-function render() {
-  const app = document.getElementById('app');
-  app.innerHTML = '';
-  if (!state.key) {
-    app.appendChild(h('<div class="gate"><h2>Browser Agent Console</h2><p>Paste your API key to watch and control browser sessions.</p><input id="k" type="password" placeholder="API key" /><button id="kb">Continue</button></div>'));
-    document.getElementById('kb').onclick = () => saveKey(document.getElementById('k').value);
-    document.getElementById('k').onkeydown = e => { if (e.key === 'Enter') saveKey(e.target.value); };
-    return;
-  }
-  const header = h('<header><h1>Browser Agent</h1><span class="muted">live control + replays</span><span class="spacer"></span><button id="open">+ New Session</button><button class="ghost" id="logout">Forget key</button></header>');
-  app.appendChild(header);
-  document.getElementById('open').onclick = openSession;
-  document.getElementById('logout').onclick = () => saveKey('');
-
-  const layout = h('<div class="layout"></div>');
-  const aside = h('<aside><h2>Sessions</h2></aside>');
-  if (!state.sessions.length) aside.appendChild(h('<div class="muted" style="padding:4px">No sessions yet.</div>'));
-  for (const s of state.sessions) {
-    const el = h('<div class="sess ' + (s.session_id === state.current ? 'active' : '') + '"><div class="id">' + esc(s.session_id) + '</div><div class="meta"><span class="dot ' + esc(s.status) + '"></span>' + esc(s.status) + (s.label ? ' \xB7 ' + esc(s.label) : '') + '</div></div>');
-    el.onclick = () => selectSession(s.session_id);
-    aside.appendChild(el);
-  }
-  layout.appendChild(aside);
-
-  const main = h('<main></main>');
-  if (!state.current) {
-    main.appendChild(h('<div class="empty"><div>Select or open a session to watch.</div></div>'));
-  } else {
-    const tb = h('<div class="toolbar"><label><input type="checkbox" id="ro" ' + (state.readOnly ? 'checked' : '') + ' /> Read-only (uncheck to take control)</label><span class="spacer"></span><button class="ghost" id="reload">Reload view</button><button class="ghost" id="close">Close session</button></div>');
-    main.appendChild(tb);
-    const stage = h('<div class="stage"></div>');
-    const src = frameSrc();
-    if (src) {
-      const f = h('<iframe allow="autoplay; clipboard-read; clipboard-write" src="' + esc(src) + '"></iframe>');
-      stage.appendChild(f);
-    } else {
-      stage.appendChild(h('<div class="empty"><div>Live view unavailable for this session.</div><div class="muted">It may be closed or still starting.</div></div>'));
-    }
-    main.appendChild(stage);
-
-    const rep = h('<div class="replays"><h3>Replays</h3></div>');
-    if (!state.replays.length) rep.appendChild(h('<div class="muted">No replays recorded.</div>'));
-    for (const r of state.replays) {
-      const status = r.stopped_at ? 'ready' : 'recording...';
-      const link = r.view_url ? '<a href="' + esc(r.view_url) + '" target="_blank" rel="noopener">view mp4</a>' : '<span class="muted">' + status + '</span>';
-      const download = r.stopped_at ? '<button class="linkish replay-download" data-rid="' + esc(r.replay_id) + '">download mp4</button>' : '';
-      rep.appendChild(h('<div class="replay"><span class="muted">' + esc(r.started_at || '') + '</span><span class="spacer"></span>' + link + download + '</div>'));
-    }
-    main.appendChild(rep);
-
-    layout.appendChild(main);
-  }
-  app.appendChild(layout);
-
-  const ro = document.getElementById('ro');
-  if (ro) ro.onchange = e => { state.readOnly = e.target.checked; render(); };
-  const reload = document.getElementById('reload');
-  if (reload) reload.onclick = () => selectSession(state.current);
-  const close = document.getElementById('close');
-  if (close) close.onclick = closeCurrent;
-  document.querySelectorAll('.replay-download').forEach(btn => {
-    btn.onclick = () => downloadReplay(btn.getAttribute('data-rid'));
-  });
-}
-
-render();
-if (state.key) { refreshSessions(); if (state.current) selectSession(state.current); }
-</script>
-</body>
-</html>`;
-}
-
-// src/api/stripe-routes.ts
-import Stripe from "stripe";
-import { Hono as Hono19 } from "hono";
-
-// src/api/connected-account-billing.ts
-var DEFAULT_CONNECTED_ACCOUNT_PRICE_ID = "price_1TtYPAS8aAcsk3TGHOgrDZiQ";
-async function ensureConnectedAccountBillingSchema() {
-  await getDb().execute(`CREATE TABLE IF NOT EXISTS connected_account_billing (
-    user_id INTEGER PRIMARY KEY,
-    stripe_subscription_id TEXT,
-    stripe_subscription_item_id TEXT,
-    price_id TEXT,
-    quantity INTEGER NOT NULL DEFAULT 0,
-    status TEXT NOT NULL DEFAULT 'pending',
-    last_error_code TEXT,
-    synced_at TEXT,
-    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-  )`);
-}
-async function getConnectedAccountBillingState(userId) {
-  await ensureConnectedAccountBillingSchema();
-  const result = await getDb().execute({
-    sql: "SELECT * FROM connected_account_billing WHERE user_id = ? LIMIT 1",
-    args: [Number(userId)]
-  });
-  return result.rows[0] ? result.rows[0] : null;
-}
-async function setConnectedAccountBillingState(input) {
-  await ensureConnectedAccountBillingSchema();
-  await getDb().execute({
-    sql: `INSERT INTO connected_account_billing
-      (user_id, stripe_subscription_id, stripe_subscription_item_id, price_id, quantity, status, last_error_code, synced_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, CASE WHEN ? THEN datetime('now') ELSE NULL END, datetime('now'))
-      ON CONFLICT(user_id) DO UPDATE SET
-        stripe_subscription_id = excluded.stripe_subscription_id,
-        stripe_subscription_item_id = excluded.stripe_subscription_item_id,
-        price_id = excluded.price_id,
-        quantity = excluded.quantity,
-        status = excluded.status,
-        last_error_code = excluded.last_error_code,
-        synced_at = CASE WHEN ? THEN datetime('now') ELSE connected_account_billing.synced_at END,
-        updated_at = datetime('now')`,
-    args: [
-      Number(input.userId),
-      input.stripeSubscriptionId,
-      input.stripeSubscriptionItemId,
-      input.priceId,
-      input.quantity,
-      input.status,
-      input.lastErrorCode,
-      input.synced ? 1 : 0,
-      input.synced ? 1 : 0
-    ]
-  });
-  const state = await getConnectedAccountBillingState(input.userId);
-  if (!state) throw new Error("connected account billing state was not persisted");
-  return state;
-}
-var ConnectedAccountBillingError = class extends Error {
-  constructor(message, code, status = 409, details) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.details = details;
-    this.name = "ConnectedAccountBillingError";
-  }
-  code;
-  status;
-  details;
-};
-function connectedAccountPriceId() {
-  const configured = process.env.CONNECTED_ACCOUNT_PRICE_ID?.trim();
-  if (configured) return configured;
-  return DEFAULT_CONNECTED_ACCOUNT_PRICE_ID || null;
-}
-function connectedAccountBillingView(actualQuantity, state) {
-  const quantity = Math.max(0, Math.round(actualQuantity));
-  return {
-    provider: "nango",
-    billingMode: "flat_recurring_credits",
-    priceId: connectedAccountPriceId(),
-    unitAmountCredits: CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
-    interval: "month",
-    quantity,
-    projectedMonthlyCredits: quantity * CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
-    status: state?.status ?? "pending",
-    lastErrorCode: state?.last_error_code ?? null,
-    syncedAt: state?.synced_at ?? null,
-    usage: CONNECTED_USAGE_RATE_POLICY.usage
-  };
-}
-function findBasePlanItem(subscription) {
-  return subscription.items.data.find((item) => !!item.price?.id && item.price.id in SUBSCRIPTION_TIERS);
-}
-function safeErrorCode(error) {
-  if (error instanceof ConnectedAccountBillingError) return error.code;
-  return "stripe_connection_billing_failed";
+  else alert('Open failed: ' + JSON.stringify(r.data));
 }
-async function persistFailure(user, quantityToPersist, error) {
-  await setConnectedAccountBillingState({
-    userId: user.id,
-    stripeSubscriptionId: user.subscription_id,
-    stripeSubscriptionItemId: null,
-    priceId: connectedAccountPriceId(),
-    quantity: quantityToPersist,
-    status: error instanceof ConnectedAccountBillingError && error.code !== "stripe_connection_billing_failed" ? "blocked" : "error",
-    lastErrorCode: safeErrorCode(error),
-    synced: false
+
+async function closeCurrent() {
+  if (!state.current) return;
+  await api('DELETE', '/sessions/' + state.current);
+  await refreshSessions();
+}
+
+async function downloadReplay(replayId) {
+  if (!state.current || !replayId) return;
+  const res = await fetch('/agent/sessions/' + encodeURIComponent(state.current) + '/replays/' + encodeURIComponent(replayId) + '/download', {
+    headers: { 'x-api-key': state.key },
   });
+  if (!res.ok) {
+    alert('Replay download failed: ' + await res.text());
+    return;
+  }
+  const blob = await res.blob();
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = state.current + '-' + replayId + '.mp4';
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
 }
-async function reconcileConnectedAccountBilling(user, actualQuantity) {
-  if (!Number.isSafeInteger(actualQuantity) || actualQuantity < 0) {
-    throw new Error("actualQuantity must be a non-negative safe integer");
+
+function frameSrc() {
+  if (!state.liveUrl) return null;
+  const sep = state.liveUrl.includes('?') ? '&' : '?';
+  return state.readOnly ? state.liveUrl + sep + 'readOnly=true' : state.liveUrl;
+}
+
+function saveKey(v) { state.key = v.trim(); localStorage.setItem(KEY_STORE, state.key); render(); if (state.key) { refreshSessions(); if (state.current) selectSession(state.current); } }
+
+function h(html) { const t = document.createElement('template'); t.innerHTML = html.trim(); return t.content.firstChild; }
+function esc(s) { return String(s == null ? '' : s).replace(/[&<>"]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c])); }
+
+function render() {
+  const app = document.getElementById('app');
+  app.innerHTML = '';
+  if (!state.key) {
+    app.appendChild(h('<div class="gate"><h2>Browser Agent Console</h2><p>Paste your API key to watch and control browser sessions.</p><input id="k" type="password" placeholder="API key" /><button id="kb">Continue</button></div>'));
+    document.getElementById('kb').onclick = () => saveKey(document.getElementById('k').value);
+    document.getElementById('k').onkeydown = e => { if (e.key === 'Enter') saveKey(e.target.value); };
+    return;
   }
-  const priceId = connectedAccountPriceId();
-  if (!priceId) {
-    const error = new ConnectedAccountBillingError(
-      "Connected-account billing is not configured.",
-      "connected_account_price_not_configured",
-      503
-    );
-    await persistFailure(user, actualQuantity, error);
-    throw error;
+  const header = h('<header><h1>Browser Agent</h1><span class="muted">live control + replays</span><span class="spacer"></span><button id="open">+ New Session</button><button class="ghost" id="logout">Forget key</button></header>');
+  app.appendChild(header);
+  document.getElementById('open').onclick = openSession;
+  document.getElementById('logout').onclick = () => saveKey('');
+
+  const layout = h('<div class="layout"></div>');
+  const aside = h('<aside><h2>Sessions</h2></aside>');
+  if (!state.sessions.length) aside.appendChild(h('<div class="muted" style="padding:4px">No sessions yet.</div>'));
+  for (const s of state.sessions) {
+    const el = h('<div class="sess ' + (s.session_id === state.current ? 'active' : '') + '"><div class="id">' + esc(s.session_id) + '</div><div class="meta"><span class="dot ' + esc(s.status) + '"></span>' + esc(s.status) + (s.label ? ' \xB7 ' + esc(s.label) : '') + '</div></div>');
+    el.onclick = () => selectSession(s.session_id);
+    aside.appendChild(el);
   }
-  if (!user.subscription_id || !(user.subscription_tier ?? "") || !Object.values(SUBSCRIPTION_TIERS).some((t) => t.tier === user.subscription_tier)) {
-    if (actualQuantity === 0) {
-      const state = await setConnectedAccountBillingState({
-        userId: user.id,
-        stripeSubscriptionId: null,
-        stripeSubscriptionItemId: null,
-        priceId,
-        quantity: 0,
-        status: "synced",
-        lastErrorCode: null,
-        synced: true
-      });
-      return connectedAccountBillingView(0, state);
+  layout.appendChild(aside);
+
+  const main = h('<main></main>');
+  if (!state.current) {
+    main.appendChild(h('<div class="empty"><div>Select or open a session to watch.</div></div>'));
+  } else {
+    const tb = h('<div class="toolbar"><label><input type="checkbox" id="ro" ' + (state.readOnly ? 'checked' : '') + ' /> Read-only (uncheck to take control)</label><span class="spacer"></span><button class="ghost" id="reload">Reload view</button><button class="ghost" id="close">Close session</button></div>');
+    main.appendChild(tb);
+    const stage = h('<div class="stage"></div>');
+    const src = frameSrc();
+    if (src) {
+      const f = h('<iframe allow="autoplay; clipboard-read; clipboard-write" src="' + esc(src) + '"></iframe>');
+      stage.appendChild(f);
+    } else {
+      stage.appendChild(h('<div class="empty"><div>Live view unavailable for this session.</div><div class="muted">It may be closed or still starting.</div></div>'));
     }
-    const error = new ConnectedAccountBillingError(
-      "An active paid plan is required before connected accounts can be billed.",
-      "paid_plan_required",
-      403
-    );
-    await persistFailure(user, actualQuantity, error);
-    throw error;
-  }
-  const existingState = await getConnectedAccountBillingState(user.id);
-  const currentQuantity = Math.max(0, existingState?.quantity ?? 0);
-  try {
-    if (actualQuantity > currentQuantity) {
-      const newConnections = actualQuantity - currentQuantity;
-      const feeMc = newConnections * CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC;
-      const debit = await debitMc(
-        user.id,
-        feeMc,
-        LedgerOperation.CONNECTED_ACCOUNT_FEE,
-        `${newConnections} connected account${newConnections === 1 ? "" : "s"} at ${CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS} credits/month`
-      );
-      if (!debit.ok) {
-        const requiredMc = feeMc;
-        const error = new ConnectedAccountBillingError(
-          `Insufficient credits to connect. Balance: ${mcToCredits(debit.balance_mc)} credits. Connecting requires ${mcToCredits(requiredMc)} credits (${mcToCredits(requiredMc - debit.balance_mc)} short). Upgrade your plan or wait for your credits to refresh.`,
-          "insufficient_credits",
-          402,
-          {
-            balanceCredits: mcToCredits(debit.balance_mc),
-            requiredCredits: mcToCredits(requiredMc),
-            shortByCredits: mcToCredits(Math.max(0, requiredMc - debit.balance_mc))
-          }
-        );
-        await persistFailure(user, currentQuantity, error);
-        throw error;
-      }
+    main.appendChild(stage);
+
+    const rep = h('<div class="replays"><h3>Replays</h3></div>');
+    if (!state.replays.length) rep.appendChild(h('<div class="muted">No replays recorded.</div>'));
+    for (const r of state.replays) {
+      const status = r.stopped_at ? 'ready' : 'recording...';
+      const link = r.view_url ? '<a href="' + esc(r.view_url) + '" target="_blank" rel="noopener">view mp4</a>' : '<span class="muted">' + status + '</span>';
+      const download = r.stopped_at ? '<button class="linkish replay-download" data-rid="' + esc(r.replay_id) + '">download mp4</button>' : '';
+      rep.appendChild(h('<div class="replay"><span class="muted">' + esc(r.started_at || '') + '</span><span class="spacer"></span>' + link + download + '</div>'));
     }
-    const state = await setConnectedAccountBillingState({
-      userId: user.id,
-      stripeSubscriptionId: user.subscription_id,
-      stripeSubscriptionItemId: null,
-      priceId,
-      quantity: actualQuantity,
-      status: "synced",
-      lastErrorCode: null,
-      synced: true
-    });
-    return connectedAccountBillingView(actualQuantity, state);
-  } catch (error) {
-    if (error instanceof ConnectedAccountBillingError) throw error;
-    await persistFailure(user, currentQuantity, error);
-    throw new ConnectedAccountBillingError(
-      "Unable to update connected-account billing.",
-      "stripe_connection_billing_failed",
-      503
-    );
+    main.appendChild(rep);
+
+    layout.appendChild(main);
   }
+  app.appendChild(layout);
+
+  const ro = document.getElementById('ro');
+  if (ro) ro.onchange = e => { state.readOnly = e.target.checked; render(); };
+  const reload = document.getElementById('reload');
+  if (reload) reload.onclick = () => selectSession(state.current);
+  const close = document.getElementById('close');
+  if (close) close.onclick = closeCurrent;
+  document.querySelectorAll('.replay-download').forEach(btn => {
+    btn.onclick = () => downloadReplay(btn.getAttribute('data-rid'));
+  });
 }
-async function currentConnectedAccountBillingView(userId, actualQuantity) {
-  return connectedAccountBillingView(actualQuantity, await getConnectedAccountBillingState(userId));
+
+render();
+if (state.key) { refreshSessions(); if (state.current) selectSession(state.current); }
+</script>
+</body>
+</html>`;
 }
 
 // src/api/stripe-routes.ts
+import Stripe from "stripe";
+import { Hono as Hono20 } from "hono";
 var stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-02-25.clover" });
-var stripeApp = new Hono19();
+var stripeApp = new Hono20();
 stripeApp.post("/webhooks", async (c) => {
   const sig = c.req.header("stripe-signature");
   const body = await c.req.text();
@@ -20026,9 +20575,16 @@ stripeApp.post("/webhooks", async (c) => {
           await creditMc(user.id, tier.credits_mc, LedgerOperation.SUBSCRIPTION, `${tier.label} subscription credits`, invoice.id, { neverExpires: tier.credits_never_expire });
           await setSubscriptionTier(user.id, tier.tier, tier.concurrency, subId ?? user.subscription_id);
           if (tier.includes_memory) {
-            const subscriptionId = subId ?? user.subscription_id;
-            await setMemoryPlan(user.id, "pro", subscriptionId ?? null);
-            await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, memory_plan: "pro" }));
+            const standaloneMemorySub = user.memory_subscription_id;
+            if (standaloneMemorySub) {
+              try {
+                await stripe.subscriptions.update(standaloneMemorySub, { cancel_at_period_end: true });
+              } catch (err) {
+                console.error("[stripe] could not wind down standalone memory subscription", standaloneMemorySub, err instanceof Error ? err.message : err);
+              }
+            }
+            await setMemoryPlan(user.id, "pro", null);
+            await syncMemoryKeyPlan(user, resolveEffectiveMemoryPlan({ ...user, memory_plan: "pro", subscription_tier: tier.tier }));
           }
           const credentials = await syncScheduledActionCredentials(user);
           if (!credentials.ok) console.warn("[stripe] scheduled-action credential sync failed:", credentials.error ?? "unknown error");
@@ -20139,7 +20695,7 @@ async function resolveUser2(customerId, emailFallback) {
 }
 
 // src/api/oauth-routes.ts
-import { Hono as Hono20 } from "hono";
+import { Hono as Hono21 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
 import { createHash as createHash6, randomBytes as randomBytes2, randomUUID as randomUUID7 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
@@ -20308,7 +20864,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 Hono20();
+var oauthApp = new Hono21();
 oauthApp.use("*", async (c, next) => {
   c.header("Access-Control-Allow-Origin", "*");
   c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -20562,8 +21118,8 @@ oauthApp.post("/oauth/token", async (c) => {
 });
 
 // src/api/chat-routes.ts
-import { Hono as Hono21 } from "hono";
-var chatApp = new Hono21();
+import { Hono as Hono22 } from "hono";
+var chatApp = new Hono22();
 function tokenOk(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -21233,7 +21789,7 @@ loadChannels();
 }
 
 // src/api/vault-routes.ts
-import { Hono as Hono22 } from "hono";
+import { Hono as Hono23 } from "hono";
 var VAULTS = ["People", "Organizations", "Deals", "Projects", "Tasks", "Communications", "Calendar"];
 var PROJECT_TYPES = ["codebase", "personal", "work", "client"];
 var PROJECT_KIND_BY_TYPE = {
@@ -21252,7 +21808,7 @@ var PROJECT_TYPE_BY_KIND = {
 var MAX_VAULT_RECORDS = 200;
 var MAX_MEMORY_READ_CONCURRENCY = 4;
 var MAX_MEMORY_READ_ATTEMPTS = 3;
-var vaultApp = new Hono22();
+var vaultApp = new Hono23();
 function validToken(token) {
   return !!token && token.startsWith("mk_") && token.length > 20 && token.length < 256;
 }
@@ -21388,7 +21944,7 @@ async function readMemory(tool, args, token) {
   }
   return result;
 }
-async function mapWithConcurrency(items, limit, map) {
+async function mapWithConcurrency2(items, limit, map) {
   const values = new Array(items.length);
   let cursor = 0;
   const worker = async () => {
@@ -21405,7 +21961,7 @@ async function readVault(vault, token) {
   const list = await readMemory("listTool", { vault }, token);
   if (!list.ok) throw new Error(list.error ?? `unable to read ${vault}`);
   const noteRefs = (list.notes ?? []).slice(0, MAX_VAULT_RECORDS);
-  const notes = await mapWithConcurrency(
+  const notes = await mapWithConcurrency2(
     noteRefs,
     MAX_MEMORY_READ_CONCURRENCY,
     ({ path: path5 }) => readMemory("getTool", { vault, path: path5 }, token)
@@ -21601,8 +22157,8 @@ vaultApp.post("/api/activity", async (c) => {
 });
 
 // src/api/schedule-routes.ts
-import { Hono as Hono23 } from "hono";
-var scheduleApp = new Hono23();
+import { Hono as Hono24 } from "hono";
+var scheduleApp = new Hono24();
 function tokenOk2(token) {
   return !!token && token.startsWith("mk_") && token.length > 10;
 }
@@ -21933,7 +22489,7 @@ loadActions();
 }
 
 // src/api/resend-inbound-routes.ts
-import { Hono as Hono24 } from "hono";
+import { Hono as Hono25 } from "hono";
 import { Resend } from "resend";
 
 // src/api/resend-support-thread.ts
@@ -22564,7 +23120,7 @@ async function relayOperatorReply(resend, email, customerEmail, threadAddress, n
   if (sent.error) throw new Error(`support reply relay failed: ${sent.error.message}`);
   return sent.data.id;
 }
-var resendInboundApp = new Hono24();
+var resendInboundApp = new Hono25();
 resendInboundApp.post("/webhooks", async (c) => {
   const apiKey = process.env.RESEND_API_KEY?.trim();
   const webhookSecret = process.env.RESEND_WEBHOOK_SECRET?.trim();
@@ -26005,7 +26561,7 @@ var requirePaidSchedulingTier = createMiddleware3(async (c, next) => {
   if (!hasPaidSchedulingAccess(user)) return c.json(paidPlanRequiredPayload(), 403);
   return next();
 });
-var app = new Hono25();
+var app = new Hono26();
 var STRIPE_API_VERSION = "2026-02-25.clover";
 function requireStripeSecret() {
   const secret2 = process.env.STRIPE_SECRET_KEY?.trim();
@@ -26054,7 +26610,7 @@ function opForCostPath(p) {
     if (p.endsWith("/search")) return "google_ads_search";
     return "google_ads_intel";
   }
-  if (p === "/reddit/thread") return "reddit_thread";
+  if (p === "/reddit/thread" || p === "/reddit/trending") return "reddit_thread";
   if (p.startsWith("/trustpilot/")) return "trustpilot_reviews";
   if (p.startsWith("/g2/")) return "g2_reviews";
   if (p.startsWith("/api/internal/site-architecture-auditor")) return "audit_site";
@@ -26226,7 +26782,26 @@ app.get("/catalog", (c) => {
 app.get("/rates", (c) => {
   return c.json(getPublicRatesPayload());
 });
+function sessionBootstrapPayload(user) {
+  return {
+    authenticated: true,
+    id: user.id,
+    email: user.email,
+    api_key: user.key_active ? user.api_key : null,
+    created_at: user.created_at,
+    balance_mc: user.balance_mc,
+    balance_credits: user.balance_mc / MC_PER_CREDIT,
+    extra_concurrency_slots: user.extra_concurrency_slots,
+    concurrency_limit: concurrencyLimitForUser(user),
+    has_concurrency_sub: !!user.concurrency_stripe_sub_id,
+    subscription_tier: user.subscription_tier,
+    subscription_concurrency: user.subscription_concurrency,
+    memory_plan: user.memory_plan ?? "free",
+    has_memory_sub: !!user.memory_subscription_id
+  };
+}
 app.get("/me", async (c) => {
+  c.header("Cache-Control", "no-store");
   const token = getCookie2(c, "session");
   if (!token) return c.json({ authenticated: false });
   const userId = verifySession(token);
@@ -26239,6 +26814,8 @@ app.get("/me", async (c) => {
     deleteCookie(c, "session", { path: "/", secure: secureCookies2, sameSite: "Strict" });
     return c.json({ authenticated: false });
   }
+  const bootstrap = sessionBootstrapPayload(foundUser);
+  if (c.req.query("bootstrap") === "1") return c.json(bootstrap);
   const refreshed = await applyMonthlyFreeRefresh(foundUser);
   const [balanceMc, stats] = await Promise.all([
     reconcileBalanceMc(refreshed.id, refreshed.balance_mc),
@@ -26246,20 +26823,7 @@ app.get("/me", async (c) => {
   ]);
   const user = { ...refreshed, balance_mc: balanceMc };
   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,
-    balance_mc: user.balance_mc,
-    balance_credits: user.balance_mc / MC_PER_CREDIT,
-    extra_concurrency_slots: user.extra_concurrency_slots,
-    concurrency_limit: concurrencyLimitForUser(user),
-    has_concurrency_sub: !!user.concurrency_stripe_sub_id,
-    subscription_tier: user.subscription_tier,
-    subscription_concurrency: user.subscription_concurrency,
-    memory_plan: user.memory_plan ?? "free",
-    has_memory_sub: !!user.memory_subscription_id,
+    ...sessionBootstrapPayload(user),
     ...stats
   });
 });
@@ -26479,6 +27043,12 @@ app.post("/memory/checkout", auth2, async (c) => {
     const body = await c.req.json().catch(() => ({}));
     const priceId = body.priceId?.trim();
     if (!priceId || !MEMORY_PLANS[priceId]) return c.json({ error: "Invalid priceId \u2014 must be a memory plan price." }, 400);
+    if (tierIncludesMemory(user.subscription_tier)) {
+      return c.json({
+        error: "Your current plan already includes Memory Pro \u2014 there is nothing to buy here.",
+        error_code: "memory_already_included"
+      }, 409);
+    }
     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 });
@@ -27402,6 +27972,30 @@ app.put("/schedule-actions/:id/connections", auth2, requireIntegrationsTier, asy
     return scheduleConnectionError(c, err, "Unable to update scheduled action service connections.");
   }
 });
+app.get("/schedule-actions/:id/runs", 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 limitRaw = Number(c.req.query("limit") ?? "50");
+  const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(Math.round(limitRaw), 1), 100) : 50;
+  const r = await memoryCall("listScheduledActionRunsTool", { id: c.req.param("id"), limit }, key);
+  return c.json(r);
+});
+app.put("/schedule-actions/:id", auth2, requirePaidSchedulingTier, 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 updates = {};
+  for (const field of ["description", "vault", "cadence", "timeOfDay", "timezone"]) {
+    if (Object.prototype.hasOwnProperty.call(body, field)) updates[field] = body[field];
+  }
+  if (Object.keys(updates).length === 0) {
+    return c.json({ ok: false, error: "Provide at least one of description, vault, cadence, timeOfDay, timezone." }, 400);
+  }
+  const r = await memoryCall("updateScheduledActionTool", { id: c.req.param("id"), ...updates }, 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);
@@ -27587,7 +28181,8 @@ app.post("/harvest/sync", auth2, async (c) => {
     proxyZip: body.proxyZip,
     debug: body.debug ?? false,
     serpOnly: body.serpOnly ?? false,
-    pages: Math.min(2, Math.max(1, body.pages ?? 1))
+    pages: Math.min(2, Math.max(1, body.pages ?? 1)),
+    recency: body.recency
   };
   const syncCost = options.serpOnly ? MC_COSTS.serp_headful : paaCostForQuestionCount(options.maxQuestions);
   const { ok: syncOk, balance_mc: syncBal } = await debitMc(user.id, syncCost, options.serpOnly ? LedgerOperation.SERP : LedgerOperation.PAA, options.query);
@@ -28074,6 +28669,11 @@ async function chargeTierChangeNow(stripeClient, subscriptionId, customerId) {
     return { ok: false, amountDue: 0, error: err instanceof Error ? err.message : "Unable to charge the plan change immediately." };
   }
 }
+app.get("/billing/offer/:slug", async (c) => {
+  const payload = getPrivateOfferPayload(c.req.param("slug").trim().toLowerCase());
+  if (!payload) return c.json({ error: "Unknown offer." }, 404);
+  return c.json(payload);
+});
 app.post("/billing/subscribe", requireAllowedOrigin, sessionAuth, async (c) => {
   try {
     const user = c.get("sessionUser");
@@ -28119,7 +28719,7 @@ app.post("/billing/subscribe", requireAllowedOrigin, sessionAuth, async (c) => {
       billing_address_collection: "required",
       customer_update: { address: "auto", name: "auto" },
       tax_id_collection: { enabled: true },
-      return_url: `${appOrigin()}/billing?subscribed=${tier.tier}`
+      return_url: tier.private_offer && offerClaimPathForTier(tier.tier) ? `${appOrigin()}${offerClaimPathForTier(tier.tier)}?purchased=${tier.tier}` : `${appOrigin()}/billing?subscribed=${tier.tier}`
     });
     return c.json({ clientSecret: session.client_secret });
   } catch (err) {
@@ -28205,7 +28805,7 @@ app.post("/billing/subscribe/terminal-checkout", auth2, async (c) => {
     const user = c.get("user");
     const raw = await c.req.json().catch(() => ({}));
     const tier = SUBSCRIPTION_TIER_BY_KEY[String(raw.tier ?? "")];
-    if (!tier) return c.json({ error: "Invalid tier. Choose starter, growth, or scale.", tiers: Object.keys(SUBSCRIPTION_TIER_BY_KEY) }, 400);
+    if (!tier) return c.json({ error: "Invalid tier. Choose starter, growth, or scale.", tiers: Object.values(SUBSCRIPTION_TIER_BY_KEY).filter((t) => !t.private_offer).map((t) => t.tier) }, 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 });
@@ -28253,7 +28853,12 @@ app.post("/billing/subscribe/terminal-checkout", auth2, async (c) => {
       tier: tier.tier,
       label: tier.label,
       monthly_usd: tier.monthly_usd,
+      amount_usd: tierAmountChargedUsd(tier),
+      billing_interval: tierBillingInterval(tier),
+      credits_per_interval: tierCreditsPerInterval(tier),
       credits_per_month: tier.credits_mc / MC_PER_CREDIT,
+      credits_never_expire: !!tier.credits_never_expire,
+      includes_memory: !!tier.includes_memory,
       concurrency: tier.concurrency,
       intro: tier.intro_coupon ? "$1 first month" : null,
       next_step: "Open checkout_url in a browser to complete payment."
@@ -28288,6 +28893,7 @@ app.get("/billing/balance", auth2, async (c) => {
     ledger
   });
 });
+app.get("/billing/summary", auth2, billingSummaryHandler);
 app.get("/billing/connected-usage/history", auth2, async (c) => {
   return c.json({
     ok: true,
@@ -28331,7 +28937,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-BJ64GCDE.js");
+  const { drainQueue } = await import("./worker-ZZHSYI3Y.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
   const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
   const [results, sweepResult, reapResult, expiredResult, blobCleanup, connectedDataArtifactCleanup] = await Promise.all([
@@ -28359,15 +28965,15 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     return c.json({ error: "Unauthorized" }, 401);
   }
   const jobId = c.req.param("id");
-  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-ZDTO7ODZ.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-YNXTFCC3.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-JHMVHENZ.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-GPZRLBVY.js");
   const job = await getExtractJob2(jobId);
   if (!job) return c.json({ error: "job not found" }, 404);
   const stored = await assembleExtractArtifacts(job, {});
   await completeExtractJob2(jobId, stored);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-ZDTO7ODZ.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-JHMVHENZ.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -28386,6 +28992,8 @@ app.on(["GET", "POST", "PUT"], "/api/inngest", serveInngest({ client: inngest, f
 app.route("/api/internal/site-architecture-auditor", siteAuditApp);
 app.route("/api/internal/memory", internalMemoryApp);
 app.route("/api/internal/billing", internalBillingApp);
+app.route("/api/internal/inbox", internalInboxApp);
+app.route("/inbox", inboxApp);
 app.route("/youtube", youtubeApp);
 app.route("/screenshot", screenshotApp);
 app.route("/facebook", facebookAdApp);
@@ -28534,4 +29142,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-SHOYO52X.js.map
+//# sourceMappingURL=server-LKVPEQFE.js.map