mcp-scraper 0.2.13 → 0.2.14

package/dist/{server-LUNOI26E.js → server-7QP6HQJJ.js}

@@ -11,11 +11,12 @@ import {
   MC_PER_CREDIT,
   browserActiveCostMc,
   classifyHarvestProblem,
+  concurrencySlotBillingInfo,
   createHarvestAttemptRecorder,
   harvestProblemResponse,
   insufficientBalanceResponse,
   serializeHarvestProblem
-} from "./chunk-ROS67BNV.js";
+} from "./chunk-BSYPATSM.js";
 import {
   SiteAuditJobRowSchema,
   cancelJob,
@@ -24,7 +25,6 @@ import {
   completeJob,
   completeWorkflowRunRecord,
   consumePasswordResetToken,
-  countActiveJobsForUser,
   countActiveUsers,
   createJob,
   createPasswordResetToken,
@@ -74,7 +74,7 @@ import {
   setPassword,
   setStripeCustomerId,
   verifyPassword
-} from "./chunk-7GCCOT3M.js";
+} from "./chunk-TL7YTFLH.js";
 import {
   BrowserDriver,
   MapsPlaceOptionsSchema,
@@ -100,7 +100,7 @@ import {
   harvestTimeoutBudget,
   liveWebToolAnnotations,
   outputBaseDir
-} from "./chunk-DKJ2XCY7.js";
+} from "./chunk-IWQTNY2E.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -113,8 +113,8 @@ import {
   runWorkflow,
   workflowDefinition,
   workflowOutputBaseDir
-} from "./chunk-AYTOCZBS.js";
-import "./chunk-RDROUQ4E.js";
+} from "./chunk-F44RBOJ5.js";
+import "./chunk-ROCXJOVY.js";
 
 // src/api/outbound-sanitize.ts
 var KEY_RENAMES = {
@@ -8029,6 +8029,179 @@ var YoutubeTranscribeBodySchema = z11.object({
   videoId: z11.string().min(1, "videoId is required")
 });
 
+// src/api/concurrency-gates.ts
+import { randomUUID } from "crypto";
+var DEFAULT_LOCK_TTL_SECONDS = 15 * 60;
+var DEFAULT_RETRY_AFTER_SECONDS = 30;
+var MAX_LOCK_TTL_SECONDS = 24 * 60 * 60;
+var schemaReady = null;
+function concurrencyLimitForUser(user) {
+  return 1 + Math.max(0, Number(user.extra_concurrency_slots ?? 0));
+}
+function concurrencyLimitExceededResponse(gate) {
+  const upgrade = concurrencySlotBillingInfo();
+  const message = `You have ${gate.active} active operation${gate.active !== 1 ? "s" : ""}. Your account allows ${gate.limit} concurrent operation${gate.limit !== 1 ? "s" : ""}. Wait for one to finish, or add an extra concurrency slot for ${upgrade.price_label} at ${upgrade.billing_url}. Terminal upgrade: ${upgrade.terminal_command}`;
+  return {
+    error: message,
+    message,
+    error_code: "concurrency_limit_exceeded",
+    error_type: "concurrency_limit",
+    retryable: true,
+    active: gate.active,
+    limit: gate.limit,
+    operation: gate.operation,
+    upgrade,
+    upgrade_url: upgrade.billing_url,
+    upgrade_command: upgrade.terminal_command
+  };
+}
+function isConcurrencyLimitBypassed(user) {
+  const raw = process.env.CONCURRENCY_LIMIT_BYPASS_EMAILS ?? process.env.HARVEST_LIMIT_BYPASS_EMAILS ?? "";
+  return raw.split(",").map((email) => email.trim()).filter(Boolean).includes(user.email);
+}
+function lockTtlModifier(ttlSeconds) {
+  const ttl = Number.isFinite(ttlSeconds) ? Math.max(30, Math.min(Math.trunc(Number(ttlSeconds)), MAX_LOCK_TTL_SECONDS)) : DEFAULT_LOCK_TTL_SECONDS;
+  return `+${ttl} seconds`;
+}
+function safeMetadata(metadata) {
+  if (!metadata) return null;
+  try {
+    return JSON.stringify(metadata).slice(0, 4e3);
+  } catch {
+    return null;
+  }
+}
+async function ensureConcurrencyGateSchema() {
+  if (!schemaReady) {
+    schemaReady = (async () => {
+      const db = getDb();
+      await db.execute(`
+        CREATE TABLE IF NOT EXISTS concurrency_locks (
+          id          TEXT PRIMARY KEY,
+          user_id     INTEGER NOT NULL REFERENCES users(id),
+          operation   TEXT NOT NULL,
+          status      TEXT NOT NULL DEFAULT 'active',
+          acquired_at TEXT NOT NULL DEFAULT (datetime('now')),
+          expires_at  TEXT NOT NULL,
+          released_at TEXT,
+          metadata    TEXT
+        )
+      `);
+      await db.execute(`CREATE INDEX IF NOT EXISTS concurrency_locks_user_status ON concurrency_locks(user_id, status, expires_at)`);
+      await db.execute(`CREATE INDEX IF NOT EXISTS concurrency_locks_operation ON concurrency_locks(operation, status, expires_at)`);
+    })();
+  }
+  return schemaReady;
+}
+async function expireConcurrencyLocksForUser(userId) {
+  await ensureConcurrencyGateSchema();
+  await getDb().execute({
+    sql: `UPDATE concurrency_locks
+          SET status = 'expired', released_at = datetime('now')
+          WHERE user_id = ? AND status = 'active' AND expires_at <= datetime('now')`,
+    args: [userId]
+  });
+}
+async function countActiveUsageForUser(userId) {
+  await ensureConcurrencyGateSchema();
+  await expireConcurrencyLocksForUser(userId);
+  const res = await getDb().execute({
+    sql: `SELECT
+            (
+              SELECT COUNT(*)
+              FROM jobs
+              WHERE user_id = ?
+                AND (status = 'pending' OR (status = 'running' AND started_at > datetime('now', '-10 minutes')))
+            ) +
+            (
+              SELECT COUNT(*)
+              FROM concurrency_locks
+              WHERE user_id = ? AND status = 'active' AND expires_at > datetime('now')
+            ) AS n`,
+    args: [userId, userId]
+  });
+  return Number(res.rows[0]?.n ?? 0);
+}
+async function reuseExistingConcurrencyGate(userId, lockId, ttlSeconds) {
+  if (!/^cl_[a-f0-9]{24,32}$/.test(lockId)) return false;
+  await ensureConcurrencyGateSchema();
+  await expireConcurrencyLocksForUser(userId);
+  const res = await getDb().execute({
+    sql: `UPDATE concurrency_locks
+          SET expires_at = datetime('now', ?)
+          WHERE id = ?
+            AND user_id = ?
+            AND status = 'active'
+            AND expires_at > datetime('now')`,
+    args: [lockTtlModifier(ttlSeconds), lockId, userId]
+  });
+  return Number(res.rowsAffected ?? 0) > 0;
+}
+async function acquireConcurrencyGate(user, operation, options = {}) {
+  await ensureConcurrencyGateSchema();
+  const limit = concurrencyLimitForUser(user);
+  if (isConcurrencyLimitBypassed(user)) {
+    return { ok: true, lockId: null, active: 0, limit, operation, bypassed: true };
+  }
+  if (options.reuseLockId && await reuseExistingConcurrencyGate(user.id, options.reuseLockId, options.ttlSeconds)) {
+    return { ok: true, lockId: null, active: await countActiveUsageForUser(user.id), limit, operation, reused: true };
+  }
+  await expireConcurrencyLocksForUser(user.id);
+  const lockId = `cl_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  const res = await getDb().execute({
+    sql: `INSERT INTO concurrency_locks (id, user_id, operation, status, expires_at, metadata)
+          SELECT ?, ?, ?, 'active', datetime('now', ?), ?
+          WHERE (
+            (
+              SELECT COUNT(*)
+              FROM jobs
+              WHERE user_id = ?
+                AND (status = 'pending' OR (status = 'running' AND started_at > datetime('now', '-10 minutes')))
+            ) +
+            (
+              SELECT COUNT(*)
+              FROM concurrency_locks
+              WHERE user_id = ? AND status = 'active' AND expires_at > datetime('now')
+            )
+          ) < ?`,
+    args: [
+      lockId,
+      user.id,
+      operation,
+      lockTtlModifier(options.ttlSeconds),
+      safeMetadata(options.metadata),
+      user.id,
+      user.id,
+      limit
+    ]
+  });
+  const active = await countActiveUsageForUser(user.id);
+  if (Number(res.rowsAffected ?? 0) > 0) {
+    return { ok: true, lockId, active, limit, operation };
+  }
+  return { ok: false, active, limit, operation, retryAfterSeconds: DEFAULT_RETRY_AFTER_SECONDS };
+}
+async function releaseConcurrencyGate(lockId) {
+  if (!lockId) return;
+  await ensureConcurrencyGateSchema();
+  await getDb().execute({
+    sql: `UPDATE concurrency_locks
+          SET status = 'released', released_at = datetime('now')
+          WHERE id = ? AND status = 'active'`,
+    args: [lockId]
+  });
+}
+async function extendConcurrencyGate(lockId, ttlSeconds = DEFAULT_LOCK_TTL_SECONDS) {
+  if (!lockId) return;
+  await ensureConcurrencyGateSchema();
+  await getDb().execute({
+    sql: `UPDATE concurrency_locks
+          SET expires_at = datetime('now', ?)
+          WHERE id = ? AND status = 'active' AND expires_at > datetime('now')`,
+    args: [lockTtlModifier(ttlSeconds), lockId]
+  });
+}
+
 // src/api/youtube-routes.ts
 var youtubeApp = new Hono2();
 youtubeApp.post("/harvest", createApiKeyAuth(), async (c) => {
@@ -8043,9 +8216,16 @@ youtubeApp.post("/harvest", createApiKeyAuth(), async (c) => {
     return c.json({ error: "channel mode requires channelHandle (@handle or UC... ID)" }, 400);
   }
   const user = c.get("user");
-  const { ok: ytOk, balance_mc: ytBal } = await debitMc(user.id, MC_COSTS.yt_channel, LedgerOperation.YT_CHANNEL, query ?? channelHandle ?? "");
-  if (!ytOk) return c.json(insufficientBalanceResponse(ytBal, MC_COSTS.yt_channel), 402);
+  const gate = await acquireConcurrencyGate(user, "youtube_harvest", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { mode, query, channelHandle }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
   try {
+    const { ok: ytOk, balance_mc: ytBal } = await debitMc(user.id, MC_COSTS.yt_channel, LedgerOperation.YT_CHANNEL, query ?? channelHandle ?? "");
+    if (!ytOk) return c.json(insufficientBalanceResponse(ytBal, MC_COSTS.yt_channel), 402);
+    debited = true;
     const normalizedChannelUrl = mode === "channel" ? buildYouTubeChannelVideosUrl(channelHandle.trim()) : void 0;
     const result = await ytHarvest({
       mode,
@@ -8070,13 +8250,15 @@ youtubeApp.post("/harvest", createApiKeyAuth(), async (c) => {
       return c.json({ error: msg }, 400);
     }
     if (err instanceof CaptchaError || msg.includes("CAPTCHA") || msg.includes("blocked")) {
-      await creditMc(user.id, MC_COSTS.yt_channel, LedgerOperation.YT_CHANNEL_REFUND, "failed call");
+      if (debited) await creditMc(user.id, MC_COSTS.yt_channel, LedgerOperation.YT_CHANNEL_REFUND, "failed call");
       await logRequestEvent({ userId: user.id, source: "youtube_harvest", status: "failed", query: mode === "search" ? query?.trim() ?? "" : channelHandle?.trim() ?? "", error: msg });
       return c.json({ error: msg }, 503);
     }
-    await creditMc(user.id, MC_COSTS.yt_channel, LedgerOperation.YT_CHANNEL_REFUND, "failed call");
+    if (debited) await creditMc(user.id, MC_COSTS.yt_channel, LedgerOperation.YT_CHANNEL_REFUND, "failed call");
     await logRequestEvent({ userId: user.id, source: "youtube_harvest", status: "failed", query: mode === "search" ? query?.trim() ?? "" : channelHandle?.trim() ?? "", error: msg });
     return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 youtubeApp.post("/transcribe", createApiKeyAuth(), async (c) => {
@@ -8088,9 +8270,16 @@ youtubeApp.post("/transcribe", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const holdMins = 5;
   const holdMc = MC_COSTS.yt_transcription * holdMins;
-  const { ok: trOk, balance_mc: trBal } = await debitMc(user.id, holdMc, LedgerOperation.TRANSCRIPTION_HOLD, id);
-  if (!trOk) return c.json(insufficientBalanceResponse(trBal, holdMc), 402);
+  const gate = await acquireConcurrencyGate(user, "youtube_transcribe", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { videoId: id }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
   try {
+    const { ok: trOk, balance_mc: trBal } = await debitMc(user.id, holdMc, LedgerOperation.TRANSCRIPTION_HOLD, id);
+    if (!trOk) return c.json(insufficientBalanceResponse(trBal, holdMc), 402);
+    debited = true;
     const result = await fetchCaptions(id);
     const lastChunk = result.chunks?.[result.chunks.length - 1];
     const chunkSecs = lastChunk && Number.isFinite(lastChunk.timestamp[1]) ? lastChunk.timestamp[1] : 0;
@@ -8115,10 +8304,12 @@ youtubeApp.post("/transcribe", createApiKeyAuth(), async (c) => {
       html: buildTranscriptHtml(result)
     });
   } catch (err) {
-    await creditMc(user.id, holdMc, LedgerOperation.TRANSCRIPTION_REFUND, "failed call");
+    if (debited) await creditMc(user.id, holdMc, LedgerOperation.TRANSCRIPTION_REFUND, "failed call");
     const msg = err instanceof Error ? err.message : String(err);
     await logRequestEvent({ userId: user.id, source: "youtube_transcribe", status: "failed", query: id, error: msg });
     return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 function buildTranscriptMarkdown(result) {
@@ -8187,6 +8378,7 @@ screenshotApp.post("/", async (c) => {
   }
   const body = parsed.data;
   const urlCheck = await validatePublicHttpUrl(body.url, { field: "url", requireHttps: false });
+  let targetUrl = urlCheck.parsed?.href;
   if (urlCheck.error) {
     if (!body.allowLocal) {
       return c.json({ error_code: "invalid_request", message: urlCheck.error }, 400);
@@ -8200,25 +8392,17 @@ screenshotApp.post("/", async (c) => {
     if (parsedFallback.protocol !== "http:" && parsedFallback.protocol !== "https:") {
       return c.json({ error: "url must use http or https" }, 400);
     }
-    const device2 = body.device === "mobile" ? "mobile" : "desktop";
-    try {
-      const buf = await captureScreenshot(parsedFallback.href, browserServiceApiKey(), device2);
-      return new Response(new Uint8Array(buf), {
-        status: 200,
-        headers: {
-          "Content-Type": "image/png",
-          "Content-Length": String(buf.length),
-          "Cache-Control": "no-store"
-        }
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return c.json({ error: msg }, 502);
-    }
+    targetUrl = parsedFallback.href;
   }
   const device = body.device === "mobile" ? "mobile" : "desktop";
+  const user = c.get("user");
+  const gate = await acquireConcurrencyGate(user, "screenshot", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { url: targetUrl, device }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   try {
-    const buf = await captureScreenshot(urlCheck.parsed.href, browserServiceApiKey(), device);
+    const buf = await captureScreenshot(targetUrl, browserServiceApiKey(), device);
     return new Response(new Uint8Array(buf), {
       status: 200,
       headers: {
@@ -8230,6 +8414,8 @@ screenshotApp.post("/", async (c) => {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return c.json({ error: msg }, 502);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 
@@ -9075,10 +9261,17 @@ facebookAdApp.post("/ad", createApiKeyAuth(), async (c) => {
   const libraryId = FacebookAdExtractor.resolveLibraryId(raw2);
   if (!libraryId) return c.json({ error: "Could not resolve a valid Facebook Ad Library ID from the provided input" }, 400);
   const fbUser = c.get("user");
-  const { ok: adOk, balance_mc: adBal } = await debitMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD, raw2);
-  if (!adOk) return c.json(insufficientBalanceResponse(adBal, MC_COSTS.fb_ad), 402);
+  const gate = await acquireConcurrencyGate(fbUser, "facebook_ad", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { libraryId }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   const driver = new BrowserDriver();
+  let debited = false;
   try {
+    const { ok: adOk, balance_mc: adBal } = await debitMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD, raw2);
+    if (!adOk) return c.json(insufficientBalanceResponse(adBal, MC_COSTS.fb_ad), 402);
+    debited = true;
     await driver.launch(kernelLaunchOpts());
     const extractor = new FacebookAdExtractor(driver);
     const result = await extractor.extract(libraryId, { openModal: body.openModal !== false });
@@ -9092,7 +9285,7 @@ facebookAdApp.post("/ad", createApiKeyAuth(), async (c) => {
     });
     return c.json(result);
   } catch (err) {
-    await creditMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD_REFUND, "failed call");
+    if (debited) await creditMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD_REFUND, "failed call");
     const msg = err instanceof Error ? err.message : String(err);
     await logRequestEvent({ userId: fbUser.id, source: "facebook_ad", status: "failed", query: raw2, error: msg });
     if (msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha")) {
@@ -9101,24 +9294,26 @@ facebookAdApp.post("/ad", createApiKeyAuth(), async (c) => {
     return c.json({ error: msg }, 500);
   } finally {
     await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 facebookAdApp.post("/page-intel", createApiKeyAuth(), async (c) => {
   const raw = await c.req.json().catch(() => ({}));
   const parsed = FacebookPageIntelBodySchema.safeParse(raw);
-  if (!parsed.success) {
-    return c.json(invalidRequest(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
-  }
+  if (!parsed.success) return c.json(invalidRequest(parsed.error.issues[0]?.message ?? "Invalid request"), 400);
   const body = parsed.data;
   const maxAds = Math.min(200, Math.max(1, body.maxAds ?? 50));
   const country = body.country?.trim().toUpperCase() ?? "US";
   const listingUrl = buildPageIntelUrl(body, country);
   const fbUser = c.get("user");
-  const { ok: fbOk, balance_mc: fbBal } = await debitMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD, body.pageId ?? body.query ?? body.libraryId ?? "");
-  if (!fbOk) return c.json(insufficientBalanceResponse(fbBal, MC_COSTS.fb_ad), 402);
+  const gate = await acquireConcurrencyGate(fbUser, "facebook_page_intel", { reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"), metadata: { pageId: body.pageId, query: body.query, libraryId: body.libraryId, country } });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   const driver = new BrowserDriver();
-  let refunded = false;
+  let refunded = false, debited = false;
   try {
+    const { ok: fbOk, balance_mc: fbBal } = await debitMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD, body.pageId ?? body.query ?? body.libraryId ?? "");
+    if (!fbOk) return c.json(insufficientBalanceResponse(fbBal, MC_COSTS.fb_ad), 402);
+    debited = true;
     await driver.launch(await kernelLaunchOptsResidential());
     await driver.navigateTo(listingUrl);
     const extractor = new FacebookAdExtractor(driver);
@@ -9133,7 +9328,7 @@ facebookAdApp.post("/page-intel", createApiKeyAuth(), async (c) => {
     return c.json(result);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    if (!refunded) await creditMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD_REFUND, "failed call");
+    if (debited && !refunded) await creditMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD_REFUND, "failed call");
     await logRequestEvent({ userId: fbUser.id, source: "facebook_page_intel", status: "failed", query: body.pageId ?? body.query ?? body.libraryId ?? "", error: msg });
     if (msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha")) {
       return c.json({ error: msg }, 503);
@@ -9141,6 +9336,7 @@ facebookAdApp.post("/page-intel", createApiKeyAuth(), async (c) => {
     return c.json({ error: msg }, 500);
   } finally {
     await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 facebookAdApp.post("/transcribe", createApiKeyAuth(), async (c) => {
@@ -9156,10 +9352,17 @@ facebookAdApp.post("/transcribe", createApiKeyAuth(), async (c) => {
   }
   const videoUrl = urlCheck.parsed.href;
   const fbUser = c.get("user");
-  const { ok, balance_mc } = await debitMc(fbUser.id, MC_COSTS.fb_transcribe, LedgerOperation.FB_TRANSCRIBE, videoUrl);
-  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.fb_transcribe), 402);
+  const gate = await acquireConcurrencyGate(fbUser, "facebook_transcribe", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { videoUrl }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   fal2.config({ credentials: process.env.FAL_KEY });
+  let debited = false;
   try {
+    const { ok, balance_mc } = await debitMc(fbUser.id, MC_COSTS.fb_transcribe, LedgerOperation.FB_TRANSCRIBE, videoUrl);
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.fb_transcribe), 402);
+    debited = true;
     const startMs = Date.now();
     const result = await fal2.subscribe("fal-ai/wizper", {
       input: { audio_url: videoUrl, task: "transcribe", language: "en" },
@@ -9182,9 +9385,11 @@ facebookAdApp.post("/transcribe", createApiKeyAuth(), async (c) => {
     return c.json({ text, chunks, durationMs, markdown: lines.join("\n") });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    await creditMc(fbUser.id, MC_COSTS.fb_transcribe, LedgerOperation.FB_TRANSCRIBE_REFUND, "failed call");
+    if (debited) await creditMc(fbUser.id, MC_COSTS.fb_transcribe, LedgerOperation.FB_TRANSCRIBE_REFUND, "failed call");
     await logRequestEvent({ userId: fbUser.id, source: "facebook_transcribe", status: "failed", query: videoUrl, error: msg });
     return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 facebookAdApp.post("/search", createApiKeyAuth(), async (c) => {
@@ -9198,11 +9403,18 @@ facebookAdApp.post("/search", createApiKeyAuth(), async (c) => {
   const maxResults = Math.min(20, Math.max(1, body.maxResults ?? 10));
   const searchUrl = `https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=${country}&q=${encodeURIComponent(body.query.trim())}&search_type=keyword_unordered`;
   const fbUser = c.get("user");
-  const { ok, balance_mc } = await debitMc(fbUser.id, MC_COSTS.fb_search, LedgerOperation.FB_SEARCH, body.query.trim());
-  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.fb_search), 402);
+  const gate = await acquireConcurrencyGate(fbUser, "facebook_search", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { query: body.query.trim(), country }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   const driver = new BrowserDriver();
   let searchRefunded = false;
+  let debited = false;
   try {
+    const { ok, balance_mc } = await debitMc(fbUser.id, MC_COSTS.fb_search, LedgerOperation.FB_SEARCH, body.query.trim());
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.fb_search), 402);
+    debited = true;
     await driver.launch(await kernelLaunchOptsResidential());
     const page = driver.getPage();
     const collated = await collectAdLibraryResults(page, searchUrl, Math.max(maxResults * 4, 40));
@@ -9263,7 +9475,7 @@ facebookAdApp.post("/search", createApiKeyAuth(), async (c) => {
     return c.json(searchResult);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    if (!searchRefunded) await creditMc(fbUser.id, MC_COSTS.fb_search, LedgerOperation.FB_SEARCH_REFUND, "failed call");
+    if (debited && !searchRefunded) await creditMc(fbUser.id, MC_COSTS.fb_search, LedgerOperation.FB_SEARCH_REFUND, "failed call");
     await logRequestEvent({ userId: fbUser.id, source: "facebook_search", status: "failed", query: body.query.trim(), error: msg });
     if (msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha")) {
       return c.json({ error: msg }, 503);
@@ -9271,6 +9483,7 @@ facebookAdApp.post("/search", createApiKeyAuth(), async (c) => {
     return c.json({ error: msg }, 500);
   } finally {
     await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 var ALLOWED_MEDIA_HOSTS = ["fbcdn.net", "cdninstagram.com", "scontent.facebook.com", "scontent.cdninstagram.com"];
@@ -10129,14 +10342,21 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
   if (!parsed.success) {
     return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
   }
-  const { ok, balance_mc } = await debitMc(
-    user.id,
-    MC_COSTS.maps_search,
-    LedgerOperation.MAPS_SEARCH,
-    [parsed.data.query, parsed.data.location].filter(Boolean).join(" ")
-  );
-  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.maps_search), 402);
+  const gate = await acquireConcurrencyGate(user, "maps_search", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { query: parsed.data.query, location: parsed.data.location }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
   try {
+    const { ok, balance_mc } = await debitMc(
+      user.id,
+      MC_COSTS.maps_search,
+      LedgerOperation.MAPS_SEARCH,
+      [parsed.data.query, parsed.data.location].filter(Boolean).join(" ")
+    );
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.maps_search), 402);
+    debited = true;
     const result = await runMapsSearchWithRotation({
       ...parsed.data,
       configuredKernelProxyId: browserServiceProxyId()
@@ -10152,7 +10372,7 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
     });
     return c.json(result);
   } catch (err) {
-    await creditMc(user.id, MC_COSTS.maps_search, LedgerOperation.REFUND, "failed maps_search call");
+    if (debited) await creditMc(user.id, MC_COSTS.maps_search, LedgerOperation.REFUND, "failed maps_search call");
     const msg = err instanceof Error ? err.message : String(err);
     await logRequestEvent({
       userId: user.id,
@@ -10164,6 +10384,8 @@ mapsApp.post("/search", createApiKeyAuth(), async (c) => {
       result: err instanceof MapsSearchRotationError ? { attempts: err.attempts } : void 0
     });
     return mapsErrorResponse(c, err, "maps_search_failed");
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 mapsApp.post("/place", createApiKeyAuth(), async (c) => {
@@ -10176,17 +10398,24 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
   if (!parsed.success) {
     return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid request" }, 400);
   }
-  const { ok, balance_mc } = await debitMc(
-    user.id,
-    MC_COSTS.maps_place,
-    LedgerOperation.MAPS_PLACE,
-    `${parsed.data.businessName} ${parsed.data.location}`
-  );
-  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.maps_place), 402);
+  const gate = await acquireConcurrencyGate(user, "maps_place", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { businessName: parsed.data.businessName, location: parsed.data.location }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   const driver = new BrowserDriver();
   const extractor = new MapsExtractor(driver);
   let reviewDebitMc = 0;
+  let debited = false;
   try {
+    const { ok, balance_mc } = await debitMc(
+      user.id,
+      MC_COSTS.maps_place,
+      LedgerOperation.MAPS_PLACE,
+      `${parsed.data.businessName} ${parsed.data.location}`
+    );
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, MC_COSTS.maps_place), 402);
+    debited = true;
     const result = await extractor.extract(parsed.data);
     const reviewCount = Array.isArray(result.reviews) ? result.reviews.length : 0;
     if (reviewCount > 0) {
@@ -10214,7 +10443,7 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
     });
     return c.json(result);
   } catch (err) {
-    await creditMc(user.id, MC_COSTS.maps_place, LedgerOperation.REFUND, "failed maps_place call");
+    if (debited) await creditMc(user.id, MC_COSTS.maps_place, LedgerOperation.REFUND, "failed maps_place call");
     if (reviewDebitMc > 0) {
       await creditMc(
         user.id,
@@ -10235,6 +10464,7 @@ mapsApp.post("/place", createApiKeyAuth(), async (c) => {
     return mapsErrorResponse(c, msg, "maps_place_failed");
   } finally {
     await driver.close();
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 
@@ -10658,18 +10888,27 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
   if (!kernelApiKey && parsed.data.proxyMode !== "none") {
     return c.json({ error: "Browser service API key is required for directory workflow Maps searches unless proxyMode is none" }, 503);
   }
-  const plan = await resolveDirectoryMarkets(parsed.data);
-  const requiredMc = plan.markets.length * MC_COSTS.maps_search;
-  if (requiredMc > 0) {
-    const debit = await debitMc(
-      user.id,
-      requiredMc,
-      LedgerOperation.MAPS_SEARCH,
-      `directory_workflow ${parsed.data.query} ${parsed.data.state} ${plan.markets.length} cities`
-    );
-    if (!debit.ok) return c.json(insufficientBalanceResponse(debit.balance_mc, requiredMc), 402);
-  }
+  const gate = await acquireConcurrencyGate(user, "directory_workflow", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    ttlSeconds: 30 * 60,
+    metadata: { query: parsed.data.query, state: parsed.data.state }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
+  let requiredMc = 0;
   try {
+    const plan = await resolveDirectoryMarkets(parsed.data);
+    requiredMc = plan.markets.length * MC_COSTS.maps_search;
+    if (requiredMc > 0) {
+      const debit = await debitMc(
+        user.id,
+        requiredMc,
+        LedgerOperation.MAPS_SEARCH,
+        `directory_workflow ${parsed.data.query} ${parsed.data.state} ${plan.markets.length} cities`
+      );
+      if (!debit.ok) return c.json(insufficientBalanceResponse(debit.balance_mc, requiredMc), 402);
+      debited = true;
+    }
     const result = await runDirectoryWorkflowFromPlan(parsed.data, plan);
     const failedCities = result.cities.filter((city) => city.status === "failed").length;
     if (failedCities > 0) {
@@ -10686,7 +10925,7 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
     });
     return c.json(result);
   } catch (err) {
-    if (requiredMc > 0) {
+    if (debited && requiredMc > 0) {
       await creditMc(user.id, requiredMc, LedgerOperation.REFUND, "failed directory_workflow call");
     }
     const message = err instanceof Error ? err.message : String(err);
@@ -10699,6 +10938,8 @@ directoryApp.post("/run", createApiKeyAuth(), async (c) => {
       error: message
     });
     return c.json({ error: message, error_code: "directory_workflow_failed", retryable: true }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 
@@ -10845,7 +11086,8 @@ async function executeWorkflowRun(input) {
       apiKey: input.user.api_key,
       apiUrl: input.apiUrl,
       outputDir: hostedWorkflowOutputDir(),
-      runId: input.runId
+      runId: input.runId,
+      headers: input.concurrencyLockId ? { "x-mcp-scraper-concurrency-lock": input.concurrencyLockId } : void 0
     });
     const manifest = await readManifestFromSummary(summary);
     await completeWorkflowRunRecord(input.runId, summary.status, manifest ?? { summary });
@@ -10878,20 +11120,29 @@ workflowApp.post("/run", createApiKeyAuth(), async (c) => {
   } catch (err) {
     return c.json({ error: err instanceof Error ? err.message : String(err) }, 400);
   }
-  const run = await createWorkflowRun({ userId: user.id, workflowId: parsed.data.workflowId, workflowInput: input });
+  const gate = await acquireConcurrencyGate(user, "workflow_run", {
+    ttlSeconds: 60 * 60,
+    metadata: { workflowId: parsed.data.workflowId }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let run = null;
   try {
+    run = await createWorkflowRun({ userId: user.id, workflowId: parsed.data.workflowId, workflowInput: input });
     const executed = await executeWorkflowRun({
       runId: run.id,
       user,
       workflowId: parsed.data.workflowId,
       workflowInput: input,
       apiUrl: originFromUrl(c.req.url),
-      webhookUrl
+      webhookUrl,
+      concurrencyLockId: gate.lockId
     });
     return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
   } catch (err) {
-    const failed = await getWorkflowRun(run.id, user.id);
+    const failed = run ? await getWorkflowRun(run.id, user.id) : null;
     return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 workflowApp.get("/runs", createApiKeyAuth(), async (c) => {
@@ -10989,8 +11240,14 @@ workflowApp.post("/schedules/:id/run", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   const schedule = await getWorkflowSchedule(c.req.param("id"), user.id);
   if (!schedule) return c.json({ error: "Schedule not found" }, 404);
-  const run = await createWorkflowRun({ userId: user.id, scheduleId: schedule.id, workflowId: schedule.workflow_id, workflowInput: schedule.input });
+  const gate = await acquireConcurrencyGate(user, "workflow_schedule_run", {
+    ttlSeconds: 60 * 60,
+    metadata: { scheduleId: schedule.id, workflowId: schedule.workflow_id }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let run = null;
   try {
+    run = await createWorkflowRun({ userId: user.id, scheduleId: schedule.id, workflowId: schedule.workflow_id, workflowInput: schedule.input });
     const executed = await executeWorkflowRun({
       runId: run.id,
       user,
@@ -10998,12 +11255,15 @@ workflowApp.post("/schedules/:id/run", createApiKeyAuth(), async (c) => {
       workflowInput: schedule.input,
       apiUrl: originFromUrl(c.req.url),
       scheduleId: schedule.id,
-      webhookUrl: schedule.webhook_url
+      webhookUrl: schedule.webhook_url,
+      concurrencyLockId: gate.lockId
     });
     return c.json({ run: exposeRun(c, executed.run, executed.artifacts), summary: executed.summary });
   } catch (err) {
-    const failed = await getWorkflowRun(run.id, user.id);
+    const failed = run ? await getWorkflowRun(run.id, user.id) : null;
     return c.json({ run: failed, error: err instanceof Error ? err.message : String(err) }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
@@ -11017,19 +11277,28 @@ async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
       continue;
     }
     const scheduledFor = schedule.next_run_at ?? now;
-    const run = await createWorkflowRun({
-      userId: user.id,
-      scheduleId: schedule.id,
-      workflowId: schedule.workflow_id,
-      workflowInput: schedule.input,
-      idempotencyKey: `${schedule.id}:${scheduledFor}`
+    const gate = await acquireConcurrencyGate(user, "workflow_schedule_dispatch", {
+      ttlSeconds: 60 * 60,
+      metadata: { scheduleId: schedule.id, workflowId: schedule.workflow_id }
     });
-    await markWorkflowScheduleRan(schedule.id, now, addCadence(scheduledFor, schedule.cadence));
-    if (run.status !== "queued") {
-      results.push({ scheduleId: schedule.id, runId: run.id, status: run.status });
+    if (!gate.ok) {
+      results.push({ scheduleId: schedule.id, status: "deferred", error: concurrencyLimitExceededResponse(gate).message });
       continue;
     }
+    let run = null;
     try {
+      run = await createWorkflowRun({
+        userId: user.id,
+        scheduleId: schedule.id,
+        workflowId: schedule.workflow_id,
+        workflowInput: schedule.input,
+        idempotencyKey: `${schedule.id}:${scheduledFor}`
+      });
+      await markWorkflowScheduleRan(schedule.id, now, addCadence(scheduledFor, schedule.cadence));
+      if (run.status !== "queued") {
+        results.push({ scheduleId: schedule.id, runId: run.id, status: run.status });
+        continue;
+      }
       const executed = await executeWorkflowRun({
         runId: run.id,
         user,
@@ -11037,11 +11306,14 @@ async function dispatchDueWorkflowSchedules(apiUrl, limit = 3) {
         workflowInput: schedule.input,
         apiUrl,
         scheduleId: schedule.id,
-        webhookUrl: schedule.webhook_url
+        webhookUrl: schedule.webhook_url,
+        concurrencyLockId: gate.lockId
       });
       results.push({ scheduleId: schedule.id, runId: executed.run.id, status: executed.run.status });
     } catch (err) {
-      results.push({ scheduleId: schedule.id, runId: run.id, status: "failed", error: err instanceof Error ? err.message : String(err) });
+      results.push({ scheduleId: schedule.id, runId: run?.id, status: "failed", error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      await releaseConcurrencyGate(gate.lockId);
     }
   }
   return { dispatched: results.length, results };
@@ -11803,26 +12075,6 @@ async function enforceSerpIntelligenceRateLimit(c, userId) {
     { "Retry-After": String(result.resetSeconds) }
   );
 }
-async function enforceSerpIntelligenceConcurrency(user) {
-  const active = await countActiveJobsForUser(user.id);
-  const limit = 1 + (user.extra_concurrency_slots ?? 0);
-  if (active < limit) return null;
-  return new Response(
-    JSON.stringify(structuredError({
-      error_code: "concurrency_limit_exceeded",
-      error_type: "concurrency_limit",
-      message: `You have ${active} active job${active !== 1 ? "s" : ""}. Your account allows ${limit} concurrent job${limit !== 1 ? "s" : ""}.`,
-      retryable: true
-    })),
-    {
-      status: 429,
-      headers: {
-        "Content-Type": "application/json",
-        "Retry-After": "30"
-      }
-    }
-  );
-}
 function pageSnapshotTargetsFromBody(body) {
   return body.targets?.length ? body.targets : body.urls.map((url) => ({
     url,
@@ -11838,17 +12090,22 @@ serpIntelligenceApp.post("/capture", async (c) => {
   if (!parsed.success) return c.json(formatZodError(parsed.error), 400);
   const limited = await enforceSerpIntelligenceRateLimit(c, user.id);
   if (limited) return limited;
-  const concurrencyLimited = await enforceSerpIntelligenceConcurrency(user);
-  if (concurrencyLimited) return concurrencyLimited;
+  const gate = await acquireConcurrencyGate(user, "serp_intelligence_capture", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { query: parsed.data.query, location: parsed.data.location }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   const cost = MC_COSTS.serp;
-  const { ok, balance_mc } = await debitMc(
-    user.id,
-    cost,
-    LedgerOperation.SERP,
-    parsed.data.query
-  );
-  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, cost), 402);
+  let debited = false;
   try {
+    const { ok, balance_mc } = await debitMc(
+      user.id,
+      cost,
+      LedgerOperation.SERP,
+      parsed.data.query
+    );
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, cost), 402);
+    debited = true;
     const result = await captureSerpIntelligenceSnapshot(parsed.data, {
       kernelApiKey: browserServiceApiKey(),
       kernelProxyId: browserServiceProxyId(),
@@ -11866,7 +12123,7 @@ serpIntelligenceApp.post("/capture", async (c) => {
     });
     return c.json(result);
   } catch (error) {
-    await creditMc(user.id, cost, LedgerOperation.REFUND, "failed serp intelligence capture");
+    if (debited) await creditMc(user.id, cost, LedgerOperation.REFUND, "failed serp intelligence capture");
     const body = error instanceof SerpIntelligenceCaptureError ? error.toJSON() : structuredError({
       error_code: "capture_failed",
       error_type: "capture_error",
@@ -11883,6 +12140,8 @@ serpIntelligenceApp.post("/capture", async (c) => {
     });
     const status = error instanceof SerpIntelligenceCaptureError ? error.httpStatus : 500;
     return c.json(body, status);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 serpIntelligenceApp.post("/page-snapshots", async (c) => {
@@ -11893,18 +12152,23 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
   if (!parsed.success) return c.json(formatZodError(parsed.error), 400);
   const limited = await enforceSerpIntelligenceRateLimit(c, user.id);
   if (limited) return limited;
-  const concurrencyLimited = await enforceSerpIntelligenceConcurrency(user);
-  if (concurrencyLimited) return concurrencyLimited;
   const targets = pageSnapshotTargetsFromBody(parsed.data);
+  const gate = await acquireConcurrencyGate(user, "serp_intelligence_page_snapshots", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { targets: targets.length }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
   const cost = targets.length * MC_COSTS.page_scrape;
-  const { ok, balance_mc } = await debitMc(
-    user.id,
-    cost,
-    LedgerOperation.EXTRACT_URL,
-    `serp intelligence page snapshots: ${targets.length}`
-  );
-  if (!ok) return c.json(insufficientBalanceResponse(balance_mc, cost), 402);
+  let debited = false;
   try {
+    const { ok, balance_mc } = await debitMc(
+      user.id,
+      cost,
+      LedgerOperation.EXTRACT_URL,
+      `serp intelligence page snapshots: ${targets.length}`
+    );
+    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, cost), 402);
+    debited = true;
     const result = await capturePageSnapshots(targets, {
       kernelApiKey: browserServiceApiKey(),
       timeoutMs: parsed.data.timeoutMs,
@@ -11921,7 +12185,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
     });
     return c.json(result);
   } catch (error) {
-    await creditMc(user.id, cost, LedgerOperation.REFUND, "failed serp intelligence page snapshots");
+    if (debited) await creditMc(user.id, cost, LedgerOperation.REFUND, "failed serp intelligence page snapshots");
     const body = structuredError({
       error_code: "page_snapshot_failed",
       error_type: "capture_error",
@@ -11936,6 +12200,8 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
       error: body.message
     });
     return c.json(body, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 
@@ -12009,7 +12275,7 @@ mcpApp.all("/", async (c) => {
 import { Hono as Hono10 } from "hono";
 
 // src/api/browser-agent-db.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var _ready = false;
 async function migrateBrowserAgent() {
   if (_ready) return;
@@ -12023,6 +12289,7 @@ async function migrateBrowserAgent() {
       status              TEXT NOT NULL DEFAULT 'open',
       label               TEXT,
       user_id             INTEGER,
+      concurrency_lock_id TEXT,
       created_at          TEXT NOT NULL DEFAULT (datetime('now')),
       closed_at           TEXT,
       last_action_at      TEXT,
@@ -12032,6 +12299,11 @@ async function migrateBrowserAgent() {
   `);
   await db.execute(`CREATE INDEX IF NOT EXISTS browser_agent_sessions_status ON browser_agent_sessions(status)`);
   await db.execute(`CREATE INDEX IF NOT EXISTS browser_agent_sessions_user ON browser_agent_sessions(user_id)`);
+  try {
+    await db.execute(`ALTER TABLE browser_agent_sessions ADD COLUMN concurrency_lock_id TEXT`);
+  } catch {
+  }
+  await db.execute(`CREATE INDEX IF NOT EXISTS browser_agent_sessions_concurrency_lock ON browser_agent_sessions(concurrency_lock_id)`);
   await db.execute(`
     CREATE TABLE IF NOT EXISTS browser_agent_actions (
       id          TEXT PRIMARY KEY,
@@ -12059,11 +12331,11 @@ async function migrateBrowserAgent() {
 }
 async function createSessionRow(input) {
   const db = getDb();
-  const id = `bas_${randomUUID().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bas_${randomUUID2().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
-    sql: `INSERT INTO browser_agent_sessions (id, runtime_session_id, live_view_url, cdp_ws_url, status, label, user_id, last_action_at)
-          VALUES (?, ?, ?, ?, 'open', ?, ?, datetime('now'))`,
-    args: [id, input.runtimeSessionId, input.liveViewUrl, input.cdpWsUrl, input.label, input.userId]
+    sql: `INSERT INTO browser_agent_sessions (id, runtime_session_id, live_view_url, cdp_ws_url, status, label, user_id, concurrency_lock_id, last_action_at)
+          VALUES (?, ?, ?, ?, 'open', ?, ?, ?, datetime('now'))`,
+    args: [id, input.runtimeSessionId, input.liveViewUrl, input.cdpWsUrl, input.label, input.userId, input.concurrencyLockId ?? null]
   });
   const row = await getSessionRow(id);
   if (!row) throw new Error("session insert failed");
@@ -12120,7 +12392,7 @@ async function recordAction(input) {
     sql: `INSERT INTO browser_agent_actions (id, session_id, type, params_json, ok, error)
           VALUES (?, ?, ?, ?, ?, ?)`,
     args: [
-      `baa_${randomUUID().replace(/-/g, "").slice(0, 20)}`,
+      `baa_${randomUUID2().replace(/-/g, "").slice(0, 20)}`,
       input.sessionId,
       input.type,
       input.params == null ? null : JSON.stringify(input.params),
@@ -12469,6 +12741,13 @@ async function replayList(runtimeSessionId) {
 
 // src/api/browser-agent-routes.ts
 var auth = createApiKeyAuth();
+var DEFAULT_BROWSER_SESSION_LOCK_TTL_SECONDS = 2 * 60 * 60;
+function browserSessionLockTtlSeconds(timeoutSeconds) {
+  if (typeof timeoutSeconds === "number" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0) {
+    return Math.max(30 * 60, Math.min(Math.trunc(timeoutSeconds) + 5 * 60, 24 * 60 * 60));
+  }
+  return DEFAULT_BROWSER_SESSION_LOCK_TTL_SECONDS;
+}
 async function charge(sessionId, userId, startedAtMs) {
   const elapsedMs = Date.now() - startedAtMs;
   const { active_ms, billed_mc } = await addActiveMs(sessionId, elapsedMs);
@@ -12524,6 +12803,8 @@ async function loadOpenSession(id, userId) {
   const row = await getSessionRow(id);
   if (!row) return null;
   if (row.user_id != null && row.user_id !== userId) return null;
+  if (row.status !== "open") return null;
+  await extendConcurrencyGate(row.concurrency_lock_id, DEFAULT_BROWSER_SESSION_LOCK_TTL_SECONDS);
   return row;
 }
 function buildBrowserAgentRoutes() {
@@ -12539,23 +12820,39 @@ function buildBrowserAgentRoutes() {
       return c.json(insufficientBalanceResponse(Number(user.balance_mc ?? 0), BROWSER_OPEN_MIN_BALANCE_MC), 402);
     }
     const body = await c.req.json().catch(() => ({}));
+    const timeoutSeconds = typeof body.timeout_seconds === "number" ? body.timeout_seconds : void 0;
+    const gate = await acquireConcurrencyGate(user, "browser_agent_session", {
+      ttlSeconds: browserSessionLockTtlSeconds(timeoutSeconds),
+      metadata: { label: typeof body.label === "string" ? body.label : null }
+    });
+    if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+    let runtimeSessionId = null;
     try {
       const created = await createSession({
-        timeoutSeconds: typeof body.timeout_seconds === "number" ? body.timeout_seconds : void 0,
+        timeoutSeconds,
         proxyId: typeof body.proxy_id === "string" ? body.proxy_id : void 0,
         profileName: typeof body.profile === "string" ? body.profile : void 0,
         disableDefaultProxy: body.disable_default_proxy === true,
         viewport: body.viewport && typeof body.viewport === "object" ? body.viewport : void 0
       });
+      runtimeSessionId = created.runtimeSessionId;
       const row = await createSessionRow({
         runtimeSessionId: created.runtimeSessionId,
         liveViewUrl: created.liveViewUrl,
         cdpWsUrl: created.cdpWsUrl,
         label: typeof body.label === "string" ? body.label : null,
-        userId: user.id
+        userId: user.id,
+        concurrencyLockId: gate.lockId
       });
       return c.json({ ...publicSession(row), watch_url: `/console/${row.id}` });
     } catch (err) {
+      if (runtimeSessionId) {
+        try {
+          await closeSession(runtimeSessionId);
+        } catch {
+        }
+      }
+      await releaseConcurrencyGate(gate.lockId);
       return c.json(failure(err), 502);
     }
   });
@@ -12586,6 +12883,7 @@ function buildBrowserAgentRoutes() {
     } catch {
     }
     await markSessionClosed(row.id);
+    await releaseConcurrencyGate(row.concurrency_lock_id);
     return c.json({ ok: true });
   });
   app2.post("/sessions/:id/goto", async (c) => {
@@ -13542,9 +13840,6 @@ app.delete("/api-key", requireAllowedOrigin, sessionAuth, async (c) => {
   await revokeApiKey(user.id);
   return c.json({ ok: true });
 });
-var BYPASS_EMAILS = new Set(
-  (process.env.HARVEST_LIMIT_BYPASS_EMAILS ?? "").split(",").map((e) => e.trim()).filter(Boolean)
-);
 var SYNC_HARVEST_TIMEOUT_OVERRIDE_MS = (() => {
   const raw = process.env.SYNC_HARVEST_TIMEOUT_MS;
   const parsed = raw === void 0 ? NaN : Number(raw);
@@ -13573,11 +13868,20 @@ function countPaaQuestions(result) {
 function paaCostForQuestionCount(questionCount) {
   return Math.max(1, questionCount) * MC_COSTS.paa;
 }
-async function checkHarvestLimits(userId, email, extraSlots = 0) {
-  if (BYPASS_EMAILS.has(email)) return null;
-  const limit = 1 + extraSlots;
-  const active = await countActiveJobsForUser(userId);
-  if (active >= limit) return { error: `You have ${active} job${active !== 1 ? "s" : ""} running. Your account allows ${limit} concurrent job${limit !== 1 ? "s" : ""}. Wait for one to finish or add a concurrency slot at mcpscraper.dev/billing.` };
+async function checkHarvestLimits(user, reuseLockId) {
+  if (reuseLockId && await reuseExistingConcurrencyGate(user.id, reuseLockId, 30 * 60)) return null;
+  if (isConcurrencyLimitBypassed(user)) return null;
+  const limit = concurrencyLimitForUser(user);
+  const active = await countActiveUsageForUser(user.id);
+  if (active >= limit) {
+    return concurrencyLimitExceededResponse({
+      ok: false,
+      active,
+      limit,
+      operation: "harvest",
+      retryAfterSeconds: 30
+    });
+  }
   return null;
 }
 app.post("/harvest", auth2, async (c) => {
@@ -13592,8 +13896,8 @@ app.post("/harvest", auth2, async (c) => {
     if (checked.error) return c.json({ error: checked.error }, 400);
     body.callback_url = checked.parsed?.href;
   }
-  const limitErr = await checkHarvestLimits(user.id, user.email, user.extra_concurrency_slots);
-  if (limitErr) return c.json(limitErr, 429);
+  const limitErr = await checkHarvestLimits(user, c.req.header("x-mcp-scraper-concurrency-lock"));
+  if (limitErr) return c.json(limitErr, 429, { "Retry-After": "30" });
   const options = {
     query: body.query.trim(),
     location: body.location,
@@ -13628,8 +13932,8 @@ app.post("/harvest/sync", auth2, async (c) => {
   const bodyResult = HarvestBodySchema.safeParse(raw);
   if (!bodyResult.success) return c.json({ error: bodyResult.error.issues[0]?.message ?? "Invalid request" }, 400);
   const body = bodyResult.data;
-  const limitErr = await checkHarvestLimits(user.id, user.email, user.extra_concurrency_slots);
-  if (limitErr) return c.json(limitErr, 429);
+  const limitErr = await checkHarvestLimits(user, c.req.header("x-mcp-scraper-concurrency-lock"));
+  if (limitErr) return c.json(limitErr, 429, { "Retry-After": "30" });
   const options = {
     query: body.query.trim(),
     location: body.location,
@@ -13788,9 +14092,16 @@ app.post("/extract-url", auth2, async (c) => {
     }
   })();
   const user = c.get("user");
-  const { ok: euOk, balance_mc: euBal } = await debitMc(user.id, MC_COSTS.page_scrape, LedgerOperation.EXTRACT_URL, new URL(canonicalUrl).hostname);
-  if (!euOk) return c.json(insufficientBalanceResponse(euBal, MC_COSTS.page_scrape), 402);
+  const gate = await acquireConcurrencyGate(user, "extract_url", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { url: canonicalUrl }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
   try {
+    const { ok: euOk, balance_mc: euBal } = await debitMc(user.id, MC_COSTS.page_scrape, LedgerOperation.EXTRACT_URL, new URL(canonicalUrl).hostname);
+    if (!euOk) return c.json(insufficientBalanceResponse(euBal, MC_COSTS.page_scrape), 402);
+    debited = true;
     const kernelApiKey = browserServiceApiKey();
     const device = screenshotDevice === "mobile" ? "mobile" : "desktop";
     const [result, pageData] = await Promise.all([
@@ -13808,9 +14119,11 @@ app.post("/extract-url", auth2, async (c) => {
     return c.json({ ...result, screenshot: screenshotMeta, branding: brandingData, media: mediaMeta });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    await creditMc(user.id, MC_COSTS.page_scrape, LedgerOperation.EXTRACT_URL, "failed call");
+    if (debited) await creditMc(user.id, MC_COSTS.page_scrape, LedgerOperation.EXTRACT_URL, "failed call");
     await logRequestEvent({ userId: user.id, source: "extract_url", status: "failed", query: canonicalUrl, error: msg });
     return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 app.post("/map-urls", auth2, async (c) => {
@@ -13822,9 +14135,16 @@ app.post("/map-urls", auth2, async (c) => {
   if (checked.error || !checked.parsed) return c.json({ error: checked.error ?? "Invalid URL" }, 400);
   const parsed = checked.parsed;
   const user = c.get("user");
-  const { ok: mapOk, balance_mc: mapBal } = await debitMc(user.id, MC_COSTS.url_map, LedgerOperation.URL_MAP, parsed.hostname);
-  if (!mapOk) return c.json(insufficientBalanceResponse(mapBal, MC_COSTS.url_map), 402);
+  const gate = await acquireConcurrencyGate(user, "map_urls", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { url: parsed.href }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
   try {
+    const { ok: mapOk, balance_mc: mapBal } = await debitMc(user.id, MC_COSTS.url_map, LedgerOperation.URL_MAP, parsed.hostname);
+    if (!mapOk) return c.json(insufficientBalanceResponse(mapBal, MC_COSTS.url_map), 402);
+    debited = true;
     const result = await spiderSite({
       startUrl: parsed.href,
       maxUrls: Math.min(2e3, Math.max(1, body.maxUrls ?? 500)),
@@ -13842,7 +14162,7 @@ app.post("/map-urls", auth2, async (c) => {
     return c.json(result);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    await creditMc(user.id, MC_COSTS.url_map, LedgerOperation.URL_MAP_REFUND, "failed call");
+    if (debited) await creditMc(user.id, MC_COSTS.url_map, LedgerOperation.URL_MAP_REFUND, "failed call");
     await logRequestEvent({
       userId: user.id,
       source: "map_urls",
@@ -13851,6 +14171,8 @@ app.post("/map-urls", auth2, async (c) => {
       error: msg
     });
     return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 app.post("/extract-site", auth2, async (c) => {
@@ -13863,9 +14185,16 @@ app.post("/extract-site", auth2, async (c) => {
   const parsed = checked.parsed;
   const user = c.get("user");
   const siteHoldMc = MC_COSTS.page_scrape * 10;
-  const { ok: siteOk, balance_mc: siteBal } = await debitMc(user.id, siteHoldMc, LedgerOperation.EXTRACT_SITE_HOLD, parsed.hostname);
-  if (!siteOk) return c.json(insufficientBalanceResponse(siteBal, siteHoldMc), 402);
+  const gate = await acquireConcurrencyGate(user, "extract_site", {
+    reuseLockId: c.req.header("x-mcp-scraper-concurrency-lock"),
+    metadata: { url: parsed.href }
+  });
+  if (!gate.ok) return c.json(concurrencyLimitExceededResponse(gate), 429, { "Retry-After": String(gate.retryAfterSeconds) });
+  let debited = false;
   try {
+    const { ok: siteOk, balance_mc: siteBal } = await debitMc(user.id, siteHoldMc, LedgerOperation.EXTRACT_SITE_HOLD, parsed.hostname);
+    if (!siteOk) return c.json(insufficientBalanceResponse(siteBal, siteHoldMc), 402);
+    debited = true;
     const result = await extractSite({
       startUrl: parsed.href,
       maxPages: Math.min(200, Math.max(1, body.maxPages ?? 100)),
@@ -13886,7 +14215,7 @@ app.post("/extract-site", auth2, async (c) => {
     });
     return c.json(result);
   } catch (err) {
-    await creditMc(user.id, siteHoldMc, LedgerOperation.EXTRACT_SITE_REFUND, "failed call");
+    if (debited) await creditMc(user.id, siteHoldMc, LedgerOperation.EXTRACT_SITE_REFUND, "failed call");
     const msg = err instanceof Error ? err.message : String(err);
     await logRequestEvent({
       userId: user.id,
@@ -13896,6 +14225,8 @@ app.post("/extract-site", auth2, async (c) => {
       error: msg
     });
     return c.json({ error: msg }, 500);
+  } finally {
+    await releaseConcurrencyGate(gate.lockId);
   }
 });
 app.post("/billing/checkout", requireAllowedOrigin, sessionAuth, async (c) => {
@@ -13964,6 +14295,60 @@ app.post("/billing/concurrency/checkout", requireAllowedOrigin, sessionAuth, asy
     return c.json({ error: message }, 500);
   }
 });
+app.post("/billing/concurrency/terminal-checkout", auth2, async (c) => {
+  try {
+    const user = c.get("user");
+    const upgrade = concurrencySlotBillingInfo();
+    if (user.concurrency_stripe_sub_id) {
+      return c.json({
+        error: "Already subscribed. Your account already has an active extra concurrency slot subscription.",
+        error_code: "concurrency_subscription_exists",
+        concurrency: {
+          extra_slots: user.extra_concurrency_slots,
+          limit: concurrencyLimitForUser(user),
+          has_subscription: true,
+          upgrade
+        }
+      }, 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 });
+    let customerId = user.stripe_customer_id;
+    if (!customerId) {
+      const customer = await stripeClient.customers.create({ email: user.email });
+      customerId = customer.id;
+      await setStripeCustomerId(user.id, customerId);
+    }
+    const session = await stripeClient.checkout.sessions.create({
+      customer: customerId,
+      mode: "subscription",
+      line_items: [{ price: CONCURRENCY_PRICE_ID, quantity: 1 }],
+      automatic_tax: { enabled: true },
+      billing_address_collection: "required",
+      customer_update: { address: "auto", name: "auto" },
+      tax_id_collection: { enabled: true },
+      success_url: `${appOrigin()}/billing?slot_added=1&source=terminal`,
+      cancel_url: `${appOrigin()}/billing?slot_cancelled=1&source=terminal`
+    });
+    if (!session.url) return c.json({ error: "Stripe did not return a checkout URL." }, 502);
+    return c.json({
+      checkout_url: session.url,
+      price: upgrade,
+      concurrency: {
+        current_extra_slots: user.extra_concurrency_slots,
+        current_limit: concurrencyLimitForUser(user),
+        after_checkout_extra_slots: user.extra_concurrency_slots + 1,
+        after_checkout_limit: concurrencyLimitForUser({ extra_concurrency_slots: user.extra_concurrency_slots + 1 })
+      },
+      next_step: "Open checkout_url in a browser, complete checkout, then restart or retry the MCP request."
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unable to start terminal checkout.";
+    console.error("[billing/concurrency/terminal-checkout]", message);
+    return c.json({ error: message }, 500);
+  }
+});
 app.post("/billing/concurrency/cancel", requireAllowedOrigin, sessionAuth, async (c) => {
   const user = c.get("sessionUser");
   if (!user.concurrency_stripe_sub_id) return c.json({ error: "No active concurrency subscription." }, 404);
@@ -13971,9 +14356,10 @@ app.post("/billing/concurrency/cancel", requireAllowedOrigin, sessionAuth, async
   if (!stripeSecret) return c.json({ error: "Stripe is not configured." }, 503);
   const stripeClient = new Stripe2(stripeSecret, { apiVersion: STRIPE_API_VERSION });
   await stripeClient.subscriptions.cancel(user.concurrency_stripe_sub_id);
-  await setExtraConcurrencySlots(user.id, Math.max(0, user.extra_concurrency_slots - 1));
+  const nextSlots = Math.max(0, user.extra_concurrency_slots - 1);
+  await setExtraConcurrencySlots(user.id, nextSlots);
   await setConcurrencySubId(user.id, null);
-  return c.json({ ok: true, concurrency_limit: user.extra_concurrency_slots });
+  return c.json({ ok: true, extra_concurrency_slots: nextSlots, concurrency_limit: 1 + nextSlots });
 });
 app.get("/billing/balance", auth2, async (c) => {
   const user = c.get("user");
@@ -14008,6 +14394,12 @@ app.post("/billing/credits", auth2, async (c) => {
     item: body.item ?? null,
     matched_cost: matchedCost ? (({ aliases, ...cost }) => cost)(matchedCost) : null,
     costs,
+    concurrency: {
+      current_extra_slots: user.extra_concurrency_slots,
+      current_limit: concurrencyLimitForUser(user),
+      has_subscription: !!user.concurrency_stripe_sub_id,
+      upgrade: concurrencySlotBillingInfo()
+    },
     ledger
   });
 });
@@ -14016,7 +14408,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-TDJQ6TH3.js");
+  const { drainQueue } = await import("./worker-OZSWIS3F.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] = await Promise.all([
@@ -14144,4 +14536,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-LUNOI26E.js.map
+//# sourceMappingURL=server-7QP6HQJJ.js.map