mcp-scraper 0.21.2 → 0.21.4

package/dist/{server-CHTX6YQA.js → server-OLOOFN5W.js}

@@ -6,7 +6,7 @@ import {
   createHarvestAttemptRecorder,
   harvestProblemResponse,
   serializeHarvestProblem
-} from "./chunk-JBME5WJR.js";
+} from "./chunk-SDHPQTFM.js";
 import {
   BrowserDriver,
   MapsSelectors,
@@ -14,7 +14,7 @@ import {
   deleteKernelProxyId,
   harvest,
   resolveKernelProxyId
-} from "./chunk-ZJDANZTQ.js";
+} from "./chunk-E5J4HJBO.js";
 import {
   HttpMcpToolExecutor,
   MemoryMcpToolExecutor,
@@ -35,7 +35,7 @@ import {
   sanitizeAttempts,
   sanitizeHarvestResult,
   transcribeMediaUrl
-} from "./chunk-ZNNYPE2U.js";
+} from "./chunk-N4JHXPW6.js";
 import {
   auditImages,
   buildLinkReport,
@@ -49,11 +49,10 @@ import {
   browserServiceProxyId,
   currentCostContext,
   kernelCostUsd,
-  migrateCostTelemetry,
   recordKernelSession,
   recordVendorUsage,
   runWithCostContext
-} from "./chunk-GMZFQRH2.js";
+} from "./chunk-MTSBI7ZH.js";
 import {
   csvRecords,
   listWorkflowDefinitions,
@@ -77,7 +76,7 @@ import {
   RawMapsOverviewSchema,
   RawMapsReviewStatsSchema
 } from "./chunk-XGIPATLV.js";
-import "./chunk-NBF4F4UT.js";
+import "./chunk-WQI7JIIN.js";
 import {
   completeExtractJob,
   countSuccessfulPages,
@@ -88,12 +87,11 @@ import {
   saveExtractPages,
   setExtractJobTotal,
   settleExtractJob
-} from "./chunk-X3NIXHHG.js";
+} from "./chunk-PNBYYAEK.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
   CREDIT_COST_CATALOG,
-  FREE_SIGNUP_MC,
   LedgerOperation,
   MC_COSTS,
   MC_PER_CREDIT,
@@ -115,9 +113,11 @@ import {
   VIDEO_ANALYSIS_LLM_MARGIN_MULTIPLE,
   browserActiveCostMc,
   concurrencySlotBillingInfo,
+  getPublicRatesPayload,
   insufficientBalanceResponse,
+  serpActualCostMc,
   vendorCostUsdToMc
-} from "./chunk-2FF4GBQ4.js";
+} from "./chunk-JHI373VB.js";
 import {
   CaptchaError,
   RECAPTCHA_INSTRUCTIONS,
@@ -143,6 +143,7 @@ import {
   creditMc,
   deactivateUser,
   debitMc,
+  debitMcIdempotent,
   deleteWorkflowSchedule,
   expireOldLots,
   failJob,
@@ -198,9 +199,10 @@ import {
   setStripeCustomerId,
   setSubscriptionTier,
   setUserMemoryCreds,
+  settleDebitMcIdempotent,
   upsertPageSnapshot,
   verifyPassword
-} from "./chunk-DZBGULWW.js";
+} from "./chunk-ICT7DDHL.js";
 
 // src/blog/registry.ts
 var posts = [
@@ -7358,7 +7360,7 @@ var siteExtractFn = inngest.createFunction(
       return buildSeoAudit(pages, job.startUrl);
     }) : null;
     const artifacts = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-HMCYUVBJ.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-NFFVMUMT.js");
       const stored = await assembleExtractArtifacts(job, { branding, imageAudit, seoAudit });
       await completeExtractJob(jobId, stored);
       return stored;
@@ -7988,8 +7990,17 @@ import { createHash as createHash2, createHmac, randomUUID, timingSafeEqual } fr
 // src/api/scheduling-access.ts
 var PAID_PLAN_REQUIRED_CODE = "paid_plan_required";
 var PAID_PLAN_REQUIRED_MESSAGE = "Scheduled Actions requires an active MCP Scraper Starter plan or higher.";
+function schedulingAccessOverrides() {
+  return new Set(
+    (process.env.SCHEDULING_ACCESS_OVERRIDE_IDENTITIES ?? "").split(",").map((identity) => identity.trim().toLowerCase()).filter(Boolean)
+  );
+}
 function hasPaidSchedulingAccess(user) {
-  return typeof user.subscription_tier === "string" && user.subscription_tier.trim().length > 0;
+  const tier = typeof user.subscription_tier === "string" ? user.subscription_tier.trim() : "";
+  const subscriptionId = typeof user.subscription_id === "string" ? user.subscription_id.trim() : "";
+  if (tier && subscriptionId) return true;
+  const identity = typeof user.email === "string" ? user.email.trim().toLowerCase() : "";
+  return identity.length > 0 && schedulingAccessOverrides().has(identity);
 }
 function paidPlanRequiredPayload() {
   return {
@@ -8026,7 +8037,7 @@ function memoryScheduleToolNeedsCredentials(upstreamName) {
 // src/api/unified-billing.ts
 var SCHEDULED_RUN_BILLING_CLASS = "scheduled_agent_run";
 var SCHEDULED_RUN_SOURCE_SURFACE = "mastra_scheduler";
-var AUTHORIZATION_TTL_MS = 30 * 60 * 1e3;
+var AUTHORIZATION_TTL_MS = 24 * 60 * 60 * 1e3;
 var UnifiedBillingError = class extends Error {
   constructor(code, message, httpStatus, details = {}) {
     super(message);
@@ -8088,6 +8099,15 @@ function safeMetadata(value) {
   if (!value) return "{}";
   return JSON.stringify(value).slice(0, 4e3);
 }
+function metadataReason(row) {
+  if (!row.metadata) return void 0;
+  try {
+    const metadata = JSON.parse(row.metadata);
+    return typeof metadata.reason === "string" ? metadata.reason : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function mapAuthorization(row, balanceMc) {
   return {
     id: row.id,
@@ -8116,23 +8136,28 @@ async function eventByKey(idempotencyKey) {
   });
   return result.rows[0] ? result.rows[0] : null;
 }
-function mapEvent(row, balanceMc, duplicate) {
-  let reason;
-  if (row.metadata) {
-    try {
-      const metadata = JSON.parse(row.metadata);
-      if (typeof metadata.reason === "string") reason = metadata.reason;
-    } catch {
-    }
-  }
+function mapStartEvent(row, balanceMc, duplicate) {
+  return {
+    id: row.id,
+    authorizationId: row.authorization_id,
+    status: "started",
+    amountMc: SCHEDULED_RUN_BASE_MC,
+    credits: SCHEDULED_RUN_BASE_MC / MC_PER_CREDIT,
+    balanceMc,
+    duplicate
+  };
+}
+function mapSettlementEvent(row, balanceMc, duplicate) {
   const rawNanos = row.raw_cost_usd_nanos == null ? null : Number(row.raw_cost_usd_nanos);
-  const modelMc = Math.max(0, Number(row.amount_mc) - SCHEDULED_RUN_BASE_MC);
+  const modelMc = Math.max(0, Number(row.amount_mc));
+  const amountMc = SCHEDULED_RUN_BASE_MC + modelMc;
+  const reason = metadataReason(row);
   return {
     id: row.id,
     authorizationId: row.authorization_id,
     status: row.status === "settled" ? "settled" : "cost_pending",
-    amountMc: Number(row.amount_mc),
-    credits: Number(row.amount_mc) / MC_PER_CREDIT,
+    amountMc,
+    credits: amountMc / MC_PER_CREDIT,
     baseMc: SCHEDULED_RUN_BASE_MC,
     modelMc,
     rawCostUsd: rawNanos == null ? null : rawNanos / USD_NANOS,
@@ -8154,7 +8179,7 @@ async function authorizeScheduledRun(args) {
     args: [user.id, SCHEDULED_RUN_BILLING_CLASS]
   });
   if (pending.rows.length > 0) {
-    throw new UnifiedBillingError("pending_cost", "a previous scheduled run has an unresolved cost", 409);
+    throw new UnifiedBillingError("pending_cost", "a previous scheduled run has an unresolved model cost", 409);
   }
   const existing = await getDb().execute({
     sql: "SELECT id, user_id, idempotency_key, status, minimum_amount_mc, maximum_amount_mc, token_hash, expires_at FROM billing_authorizations WHERE idempotency_key = ? LIMIT 1",
@@ -8163,14 +8188,9 @@ async function authorizeScheduledRun(args) {
   if (existing.rows[0]) {
     const row = existing.rows[0];
     if (Number(row.user_id) !== user.id) {
-      throw new UnifiedBillingError(
-        "invalid_request",
-        "the idempotency key is already in use by another billing identity",
-        409
-      );
+      throw new UnifiedBillingError("invalid_request", "the idempotency key is already in use by another billing identity", 409);
     }
-    const balanceMc2 = await reconcileBalanceMc(user.id, user.balance_mc);
-    return mapAuthorization(row, balanceMc2);
+    return mapAuthorization(row, await reconcileBalanceMc(user.id, user.balance_mc));
   }
   const maximumCredits = args.maximumCredits ?? SCHEDULED_RUN_DEFAULT_MAX_CREDITS;
   if (!Number.isFinite(maximumCredits) || maximumCredits < SCHEDULED_RUN_BASE_MC / MC_PER_CREDIT) {
@@ -8191,17 +8211,7 @@ async function authorizeScheduledRun(args) {
   const expiresAt = new Date(Date.now() + AUTHORIZATION_TTL_MS).toISOString();
   const inserted = await getDb().execute({
     sql: "INSERT OR IGNORE INTO billing_authorizations (id, user_id, idempotency_key, billing_class, status, minimum_amount_mc, maximum_amount_mc, token_hash, metadata, expires_at) VALUES (?, ?, ?, ?, 'authorized', ?, ?, ?, ?, ?)",
-    args: [
-      id,
-      user.id,
-      idempotencyKey,
-      SCHEDULED_RUN_BILLING_CLASS,
-      SCHEDULED_RUN_BASE_MC,
-      maximumMc,
-      tokenHash(token),
-      safeMetadata(args.metadata),
-      expiresAt
-    ]
+    args: [id, user.id, idempotencyKey, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_BASE_MC, maximumMc, tokenHash(token), safeMetadata(args.metadata), expiresAt]
   });
   if (inserted.rowsAffected === 0) {
     const raced = await getDb().execute({
@@ -8211,11 +8221,7 @@ async function authorizeScheduledRun(args) {
     if (!raced.rows[0]) throw new Error("billing authorization insert raced without a readable winner");
     const row = raced.rows[0];
     if (Number(row.user_id) !== user.id) {
-      throw new UnifiedBillingError(
-        "invalid_request",
-        "the idempotency key is already in use by another billing identity",
-        409
-      );
+      throw new UnifiedBillingError("invalid_request", "the idempotency key is already in use by another billing identity", 409);
     }
     return mapAuthorization(row, balanceMc);
   }
@@ -8232,180 +8238,235 @@ async function authorizeScheduledRun(args) {
     reservationMode: "balance_check"
   };
 }
-async function settleScheduledRun(args) {
-  const identity = normalizeIdentity(args.identity);
-  const user = await getUserByEmail(identity);
-  if (!user) throw new UnifiedBillingError("user_not_found", "billing identity was not found", 404);
-  const authorization = await authorizationById(args.authorizationId);
+async function startScheduledRun(args) {
+  const user = await resolveSchedulingUser(args.identity);
+  let authorization = await authorizationById(args.authorizationId);
   if (!authorization || Number(authorization.user_id) !== user.id) {
     throw new UnifiedBillingError("authorization_not_found", "billing authorization was not found", 404);
   }
   verifyToken(authorization, args.authorizationToken);
-  const settlementKey = authorization.id + ":settlement";
-  const existing = await eventByKey(settlementKey);
-  if (existing) {
-    const balanceMc = await reconcileBalanceMc(user.id, user.balance_mc);
-    if (existing.status === "settling") {
-      throw new UnifiedBillingError("settlement_in_progress", "scheduled-run settlement is already in progress", 409);
-    }
-    return mapEvent(existing, balanceMc, true);
+  const startKey = authorization.id + ":start";
+  const existing = await eventByKey(startKey);
+  if (existing?.status === "settled") {
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'started' WHERE id = ? AND status IN ('authorized', 'starting')",
+      args: [authorization.id]
+    });
+    return mapStartEvent(existing, await reconcileBalanceMc(user.id, user.balance_mc), true);
   }
-  if (authorization.status !== "authorized") {
-    throw new UnifiedBillingError("authorization_closed", "billing authorization is no longer open", 409);
+  if (!hasPaidSchedulingAccess(user)) {
+    throw new UnifiedBillingError(PAID_PLAN_REQUIRED_CODE, PAID_PLAN_REQUIRED_MESSAGE, 403);
   }
-  if (Date.parse(authorization.expires_at) <= Date.now()) {
+  if (authorization.status === "authorized") {
+    if (Date.parse(authorization.expires_at) <= Date.now()) {
+      await getDb().execute({
+        sql: "UPDATE billing_authorizations SET status = 'expired' WHERE id = ? AND status = 'authorized'",
+        args: [authorization.id]
+      });
+      throw new UnifiedBillingError("authorization_expired", "billing authorization expired before execution started", 409);
+    }
     await getDb().execute({
-      sql: "UPDATE billing_authorizations SET status = 'expired' WHERE id = ? AND status = 'authorized'",
+      sql: "UPDATE billing_authorizations SET status = 'starting' WHERE id = ? AND status = 'authorized'",
       args: [authorization.id]
     });
-    throw new UnifiedBillingError("authorization_expired", "billing authorization expired before settlement", 409);
+    authorization = await authorizationById(authorization.id);
   }
-  const rawCostUsd = args.rawCostUsd ?? null;
-  if (args.modelCostStatus === "reported" && (rawCostUsd == null || !Number.isFinite(rawCostUsd) || rawCostUsd < 0)) {
-    throw new UnifiedBillingError("invalid_request", "reported model cost must be a finite non-negative number", 400);
+  if (!authorization || !["starting", "started"].includes(authorization.status)) {
+    throw new UnifiedBillingError("authorization_closed", "billing authorization is no longer startable", 409);
   }
-  if (args.modelCostStatus === "not_applicable" && rawCostUsd != null && rawCostUsd !== 0) {
-    throw new UnifiedBillingError("invalid_request", "not_applicable model cost cannot include a non-zero cost", 400);
-  }
-  const eventId = randomUUID();
-  const rawCostNanos = rawCostUsd == null ? null : Math.round(rawCostUsd * USD_NANOS);
-  const modelMc = rawCostUsd == null ? 0 : vendorCostUsdToMc(rawCostUsd, SCHEDULED_AGENT_LLM_MARKUP_BPS);
-  const totalMc = SCHEDULED_RUN_BASE_MC + modelMc;
-  const pendingReason = args.modelCostStatus === "missing" ? "openrouter_cost_missing" : totalMc > Number(authorization.maximum_amount_mc) ? "max_credits_per_run_exceeded" : null;
-  if (pendingReason) {
+  const eventId = existing?.id ?? randomUUID();
+  if (!existing) {
     await getDb().execute({
-      sql: "INSERT INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, raw_cost_usd_nanos, multiplier_bps, input_tokens, output_tokens, cached_tokens, model_steps, metadata) VALUES (?, ?, ?, ?, ?, ?, 'cost_pending', ?, ?, ?, ?, ?, ?, ?, ?)",
+      sql: "INSERT OR IGNORE INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, multiplier_bps, metadata) VALUES (?, ?, ?, ?, ?, ?, 'capturing', ?, ?, ?)",
       args: [
         eventId,
         user.id,
         authorization.id,
-        settlementKey,
+        startKey,
         SCHEDULED_RUN_BILLING_CLASS,
         SCHEDULED_RUN_SOURCE_SURFACE,
-        totalMc,
-        rawCostNanos,
+        SCHEDULED_RUN_BASE_MC,
         SCHEDULED_AGENT_LLM_MARKUP_BPS,
-        Math.max(0, Math.round(args.inputTokens ?? 0)),
-        Math.max(0, Math.round(args.outputTokens ?? 0)),
-        Math.max(0, Math.round(args.cachedTokens ?? 0)),
-        Math.max(0, Math.round(args.modelSteps ?? 0)),
-        safeMetadata({ ...args.metadata, reason: pendingReason })
+        safeMetadata({ ...args.metadata, billingPhase: "start", chargeMode: "base_capture" })
       ]
     });
-    await getDb().execute({
-      sql: "UPDATE billing_authorizations SET status = 'cost_pending', settled_at = datetime('now') WHERE id = ?",
-      args: [authorization.id]
-    });
-    return {
-      id: eventId,
-      authorizationId: authorization.id,
-      status: "cost_pending",
-      amountMc: totalMc,
-      credits: totalMc / MC_PER_CREDIT,
-      baseMc: SCHEDULED_RUN_BASE_MC,
-      modelMc,
-      rawCostUsd,
-      multiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
-      balanceMc: await reconcileBalanceMc(user.id, user.balance_mc),
-      reason: pendingReason,
-      duplicate: false
-    };
   }
-  const claimed = await getDb().execute({
-    sql: "INSERT OR IGNORE INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, raw_cost_usd_nanos, multiplier_bps, input_tokens, output_tokens, cached_tokens, model_steps, metadata) VALUES (?, ?, ?, ?, ?, ?, 'settling', ?, ?, ?, ?, ?, ?, ?, ?)",
-    args: [
-      eventId,
-      user.id,
-      authorization.id,
-      settlementKey,
-      SCHEDULED_RUN_BILLING_CLASS,
-      SCHEDULED_RUN_SOURCE_SURFACE,
-      totalMc,
-      rawCostNanos,
-      SCHEDULED_AGENT_LLM_MARKUP_BPS,
-      Math.max(0, Math.round(args.inputTokens ?? 0)),
-      Math.max(0, Math.round(args.outputTokens ?? 0)),
-      Math.max(0, Math.round(args.cachedTokens ?? 0)),
-      Math.max(0, Math.round(args.modelSteps ?? 0)),
-      safeMetadata(args.metadata)
-    ]
-  });
-  if (claimed.rowsAffected === 0) {
-    const raced = await eventByKey(settlementKey);
-    if (!raced) throw new Error("billing settlement raced without a readable winner");
-    if (raced.status === "settling") {
-      throw new UnifiedBillingError("settlement_in_progress", "scheduled-run settlement is already in progress", 409);
-    }
-    return mapEvent(raced, await reconcileBalanceMc(user.id, user.balance_mc), true);
-  }
-  const debit = await debitMc(
+  const debit = await debitMcIdempotent(
     user.id,
-    totalMc,
+    SCHEDULED_RUN_BASE_MC,
     LedgerOperation.SCHEDULED_RUN,
-    "scheduled-run:" + authorization.id
+    "scheduled-run:" + authorization.id + ":base",
+    startKey
   );
   if (!debit.ok) {
-    const metadata = safeMetadata({ ...args.metadata, reason: "insufficient_credits_at_settlement" });
     await getDb().execute({
-      sql: "UPDATE billing_events SET status = 'cost_pending', metadata = ? WHERE id = ?",
-      args: [metadata, eventId]
-    });
-    await getDb().execute({
-      sql: "UPDATE billing_authorizations SET status = 'cost_pending', settled_at = datetime('now') WHERE id = ?",
+      sql: "UPDATE billing_authorizations SET status = 'authorized' WHERE id = ? AND status = 'starting'",
       args: [authorization.id]
     });
-    return {
-      id: eventId,
-      authorizationId: authorization.id,
-      status: "cost_pending",
-      amountMc: totalMc,
-      credits: totalMc / MC_PER_CREDIT,
-      baseMc: SCHEDULED_RUN_BASE_MC,
+    throw new UnifiedBillingError(
+      "insufficient_credits",
+      "the wallet could not capture the scheduled-run base charge",
+      402,
+      { balanceMc: debit.balance_mc, requiredMc: SCHEDULED_RUN_BASE_MC }
+    );
+  }
+  await getDb().execute({
+    sql: "UPDATE billing_events SET status = 'settled', settled_at = datetime('now') WHERE idempotency_key = ? AND status = 'capturing'",
+    args: [startKey]
+  });
+  await getDb().execute({
+    sql: "UPDATE billing_authorizations SET status = 'started' WHERE id = ? AND status IN ('authorized', 'starting', 'started')",
+    args: [authorization.id]
+  });
+  const started = await eventByKey(startKey);
+  if (!started) throw new Error("scheduled-run base capture completed without an event receipt");
+  return mapStartEvent(started, debit.balance_mc, debit.duplicate);
+}
+function validateModelCost(args) {
+  const rawCostUsd = args.rawCostUsd ?? null;
+  if (args.modelCostStatus === "reported" && (rawCostUsd == null || !Number.isFinite(rawCostUsd) || rawCostUsd < 0)) {
+    throw new UnifiedBillingError("invalid_request", "reported model cost must be a finite non-negative number", 400);
+  }
+  if (args.modelCostStatus === "not_applicable" && rawCostUsd != null && rawCostUsd !== 0) {
+    throw new UnifiedBillingError("invalid_request", "not_applicable model cost cannot include a non-zero cost", 400);
+  }
+  return rawCostUsd;
+}
+async function recoverSettlement(row, user, authorization, duplicate) {
+  const modelMc = Math.max(0, Number(row.amount_mc));
+  let balanceMc = await reconcileBalanceMc(user.id, user.balance_mc);
+  if (modelMc > 0) {
+    const debit = await debitMcIdempotent(
+      user.id,
       modelMc,
-      rawCostUsd,
-      multiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
-      balanceMc: debit.balance_mc,
-      reason: "insufficient_credits_at_settlement",
-      duplicate: false
-    };
+      LedgerOperation.SCHEDULED_RUN,
+      "scheduled-run:" + authorization.id + ":model",
+      authorization.id + ":model"
+    );
+    balanceMc = debit.balance_mc;
+    if (!debit.ok) {
+      await getDb().execute({
+        sql: "UPDATE billing_events SET status = 'cost_pending', metadata = ? WHERE id = ? AND status = 'settling'",
+        args: [safeMetadata({ reason: "insufficient_credits_for_model_delta", billingPhase: "settlement", chargeMode: "model_delta" }), row.id]
+      });
+      await getDb().execute({
+        sql: "UPDATE billing_authorizations SET status = 'cost_pending' WHERE id = ? AND status IN ('started', 'cost_pending')",
+        args: [authorization.id]
+      });
+      const pending = await eventByKey(authorization.id + ":settlement");
+      if (!pending) throw new Error("scheduled-run pending settlement lost its event");
+      return mapSettlementEvent(pending, balanceMc, duplicate);
+    }
   }
   await getDb().execute({
-    sql: "UPDATE billing_events SET status = 'settled', settled_at = datetime('now') WHERE id = ?",
-    args: [eventId]
+    sql: "UPDATE billing_events SET status = 'settled', settled_at = datetime('now') WHERE id = ? AND status = 'settling'",
+    args: [row.id]
   });
   await getDb().execute({
-    sql: "UPDATE billing_authorizations SET status = 'settled', settled_at = datetime('now') WHERE id = ?",
+    sql: "UPDATE billing_authorizations SET status = 'settled', settled_at = datetime('now') WHERE id = ? AND status IN ('started', 'cost_pending', 'settled')",
     args: [authorization.id]
   });
-  return {
-    id: eventId,
-    authorizationId: authorization.id,
-    status: "settled",
-    amountMc: totalMc,
-    credits: totalMc / MC_PER_CREDIT,
-    baseMc: SCHEDULED_RUN_BASE_MC,
+  const settled = await eventByKey(authorization.id + ":settlement");
+  if (!settled) throw new Error("scheduled-run settlement completed without an event receipt");
+  return mapSettlementEvent(settled, balanceMc, duplicate);
+}
+async function settleScheduledRun(args) {
+  const user = await resolveSchedulingUser(args.identity);
+  let authorization = await authorizationById(args.authorizationId);
+  if (!authorization || Number(authorization.user_id) !== user.id) {
+    throw new UnifiedBillingError("authorization_not_found", "billing authorization was not found", 404);
+  }
+  verifyToken(authorization, args.authorizationToken);
+  const rawCostUsd = validateModelCost(args);
+  const startEvent = await eventByKey(authorization.id + ":start");
+  if (!startEvent || startEvent.status !== "settled") {
+    throw new UnifiedBillingError("authorization_closed", "scheduled-run settlement requires a captured start", 409);
+  }
+  if (authorization.status === "starting") {
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'started' WHERE id = ? AND status = 'starting'",
+      args: [authorization.id]
+    });
+    authorization = await authorizationById(authorization.id);
+  }
+  if (!authorization || !["started", "cost_pending", "settled"].includes(authorization.status)) {
+    throw new UnifiedBillingError("authorization_closed", "billing authorization is not open for settlement", 409);
+  }
+  const settlementKey = authorization.id + ":settlement";
+  let existing = await eventByKey(settlementKey);
+  if (existing?.status === "settled") {
+    return mapSettlementEvent(existing, await reconcileBalanceMc(user.id, user.balance_mc), true);
+  }
+  if (existing?.status === "settling") {
+    return recoverSettlement(existing, user, authorization, true);
+  }
+  const hadExistingClaim = Boolean(existing);
+  const rawCostNanos = rawCostUsd == null ? null : Math.round(rawCostUsd * USD_NANOS);
+  const modelMc = rawCostUsd == null ? 0 : vendorCostUsdToMc(rawCostUsd, SCHEDULED_AGENT_LLM_MARKUP_BPS);
+  const maximumModelMc = Math.max(0, Number(authorization.maximum_amount_mc) - SCHEDULED_RUN_BASE_MC);
+  const pendingReason = args.modelCostStatus === "missing" ? "openrouter_cost_missing" : modelMc > maximumModelMc ? "max_credits_per_run_exceeded" : null;
+  const metadata = safeMetadata({
+    ...args.metadata,
+    billingPhase: "settlement",
+    chargeMode: "model_delta",
+    ...pendingReason ? { reason: pendingReason } : {}
+  });
+  const eventId = existing?.id ?? randomUUID();
+  const status = pendingReason ? "cost_pending" : "settling";
+  const eventValues = [
     modelMc,
-    rawCostUsd,
-    multiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
-    balanceMc: debit.balance_mc,
-    duplicate: false
-  };
+    rawCostNanos,
+    SCHEDULED_AGENT_LLM_MARKUP_BPS,
+    Math.max(0, Math.round(args.inputTokens ?? 0)),
+    Math.max(0, Math.round(args.outputTokens ?? 0)),
+    Math.max(0, Math.round(args.cachedTokens ?? 0)),
+    Math.max(0, Math.round(args.modelSteps ?? 0)),
+    metadata
+  ];
+  if (existing) {
+    await getDb().execute({
+      sql: "UPDATE billing_events SET status = ?, amount_mc = ?, raw_cost_usd_nanos = ?, multiplier_bps = ?, input_tokens = ?, output_tokens = ?, cached_tokens = ?, model_steps = ?, metadata = ?, settled_at = NULL WHERE id = ? AND status = 'cost_pending'",
+      args: [status, ...eventValues, existing.id]
+    });
+  } else {
+    await getDb().execute({
+      sql: "INSERT OR IGNORE INTO billing_events (id, user_id, authorization_id, idempotency_key, billing_class, source_surface, status, amount_mc, raw_cost_usd_nanos, multiplier_bps, input_tokens, output_tokens, cached_tokens, model_steps, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+      args: [eventId, user.id, authorization.id, settlementKey, SCHEDULED_RUN_BILLING_CLASS, SCHEDULED_RUN_SOURCE_SURFACE, status, ...eventValues]
+    });
+  }
+  existing = await eventByKey(settlementKey);
+  if (!existing) throw new Error("scheduled-run settlement claim was not readable");
+  const duplicateClaim = hadExistingClaim || eventId !== existing.id;
+  if (existing.status === "settled") {
+    return mapSettlementEvent(existing, await reconcileBalanceMc(user.id, user.balance_mc), true);
+  }
+  if (existing.status === "cost_pending") {
+    await getDb().execute({
+      sql: "UPDATE billing_authorizations SET status = 'cost_pending' WHERE id = ? AND status IN ('started', 'cost_pending')",
+      args: [authorization.id]
+    });
+    return mapSettlementEvent(existing, await reconcileBalanceMc(user.id, user.balance_mc), duplicateClaim);
+  }
+  if (existing.status !== "settling") {
+    throw new UnifiedBillingError("settlement_in_progress", "scheduled-run settlement could not be claimed", 409);
+  }
+  return recoverSettlement(existing, user, authorization, duplicateClaim);
 }
 async function voidScheduledRunAuthorization(args) {
-  const identity = normalizeIdentity(args.identity);
-  const user = await getUserByEmail(identity);
-  if (!user) throw new UnifiedBillingError("user_not_found", "billing identity was not found", 404);
+  const user = await resolveSchedulingUser(args.identity);
   const authorization = await authorizationById(args.authorizationId);
   if (!authorization || Number(authorization.user_id) !== user.id) {
     throw new UnifiedBillingError("authorization_not_found", "billing authorization was not found", 404);
   }
   verifyToken(authorization, args.authorizationToken);
   if (authorization.status === "authorized") {
-    await getDb().execute({
+    const result = await getDb().execute({
       sql: "UPDATE billing_authorizations SET status = 'void', metadata = ?, settled_at = datetime('now') WHERE id = ? AND status = 'authorized'",
       args: [safeMetadata({ reason: args.reason ?? "voided_before_execution" }), authorization.id]
     });
-    return { ok: true, status: "void" };
+    if (result.rowsAffected > 0) return { ok: true, status: "void" };
+    const raced = await authorizationById(authorization.id);
+    return { ok: true, status: raced?.status ?? "closed" };
   }
   return { ok: true, status: authorization.status };
 }
@@ -8609,6 +8670,12 @@ var settleSchema = z10.object({
   modelSteps: z10.number().finite().nonnegative().optional(),
   metadata: metadataSchema
 });
+var startSchema = z10.object({
+  identity: z10.string().min(1).max(320),
+  authorizationId: z10.string().uuid(),
+  authorizationToken: z10.string().min(20).max(500),
+  metadata: metadataSchema
+});
 var voidSchema = z10.object({
   identity: z10.string().min(1).max(320),
   authorizationId: z10.string().uuid(),
@@ -8704,6 +8771,19 @@ internalBillingApp.post("/scheduled-run/settle", async (c) => {
     return c.json(response.body, response.status);
   }
 });
+internalBillingApp.post("/scheduled-run/start", async (c) => {
+  const parsed = startSchema.safeParse(await c.req.json().catch(() => null));
+  if (!parsed.success) {
+    return c.json({ ok: false, error_code: "invalid_request", error: "invalid scheduled-run start request" }, 400);
+  }
+  try {
+    const start = await startScheduledRun(parsed.data);
+    return c.json({ ok: true, start });
+  } catch (error) {
+    const response = billingError(error);
+    return c.json(response.body, response.status);
+  }
+});
 internalBillingApp.post("/scheduled-run/void", async (c) => {
   const parsed = voidSchema.safeParse(await c.req.json().catch(() => null));
   if (!parsed.success) {
@@ -10924,6 +11004,15 @@ function buildPageIntelUrl(body, country) {
   if (body.pageId?.trim()) return `https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=${country}&is_targeted_country=false&media_type=all&search_type=page&view_all_page_id=${body.pageId.trim()}`;
   return `https://www.facebook.com/ads/library/?active_status=all&ad_type=all&country=${country}&q=${encodeURIComponent(body.query.trim())}&search_type=keyword_unordered`;
 }
+function pageIntelRequestContext(body) {
+  const country = body.country?.trim().toUpperCase() ?? "US";
+  return {
+    country,
+    maxAds: Math.min(200, Math.max(1, body.maxAds ?? 50)),
+    listingUrl: buildPageIntelUrl(body, country),
+    subject: body.pageId ?? body.query ?? body.libraryId ?? ""
+  };
+}
 function normalizeAdvertiserName(value) {
   return value.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
 }
@@ -11037,16 +11126,14 @@ facebookAdApp.post("/page-intel", createApiKeyAuth(), async (c) => {
   const parsed = FacebookPageIntelBodySchema.safeParse(raw);
   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 { country, maxAds, listingUrl, subject } = pageIntelRequestContext(body);
   const fbUser = c.get("user");
   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, 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 ?? "");
+    const { ok: fbOk, balance_mc: fbBal } = await debitMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD, subject);
     if (!fbOk) return c.json(insufficientBalanceResponse(fbBal, MC_COSTS.fb_ad), 402);
     debited = true;
     await driver.launch(await kernelLaunchOptsResidential());
@@ -11056,17 +11143,17 @@ facebookAdApp.post("/page-intel", createApiKeyAuth(), async (c) => {
     if (result.ads.length === 0 && await detectSoftBlock(driver)) {
       await creditMc(fbUser.id, MC_COSTS.fb_ad, LedgerOperation.FB_AD_REFUND, "soft-block empty result");
       refunded = true;
-      await logRequestEvent({ userId: fbUser.id, source: "facebook_page_intel", status: "failed", query: body.pageId ?? body.query ?? body.libraryId ?? "", error: "soft-block: empty result refunded" });
+      await logRequestEvent({ userId: fbUser.id, source: "facebook_page_intel", status: "failed", query: subject, error: "soft-block: empty result refunded" });
       return c.json({ error: "soft-block: no ads returned (refunded)" }, 503);
     }
     const match = assessPageIntelMatch(body, result);
     const output = { ...result, ...match };
-    await logRequestEvent({ userId: fbUser.id, source: "facebook_page_intel", status: "done", query: body.pageId ?? body.query ?? body.libraryId ?? "", resultCount: result.ads.length, result: output });
+    await logRequestEvent({ userId: fbUser.id, source: "facebook_page_intel", status: "done", query: subject, resultCount: result.ads.length, result: output });
     return c.json(output);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     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 });
+    await logRequestEvent({ userId: fbUser.id, source: "facebook_page_intel", status: "failed", query: subject, error: msg });
     if (msg.toLowerCase().includes("blocked") || msg.toLowerCase().includes("captcha")) {
       return c.json({ error: msg }, 503);
     }
@@ -15004,6 +15091,7 @@ workflowApp.post("/cron/dispatch", async (c) => {
 
 // src/api/serp-intelligence-routes.ts
 import { Hono as Hono16 } from "hono";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
 
 // src/serp-intelligence/page-snapshot-extractor.ts
 import { createHash as createHash3 } from "crypto";
@@ -15397,12 +15485,22 @@ var SerpIntelligencePageSnapshotRequestSchema = z24.object({
   sourcePosition: z24.number().int().min(1).optional()
 }).strict();
 var SerpIntelligencePageSnapshotsBodySchema = z24.object({
-  urls: z24.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25),
+  urls: z24.array(SerpIntelligencePublicHttpUrlSchema).min(1).max(25).optional(),
   targets: z24.array(SerpIntelligencePageSnapshotRequestSchema).min(1).max(25).optional(),
   maxConcurrency: z24.number().int().min(1).max(5).default(2),
   timeoutMs: z24.number().int().min(1e3).max(6e4).default(15e3),
   debug: z24.boolean().default(false)
-}).strict();
+}).strict().superRefine((body, ctx) => {
+  const hasUrls = Boolean(body.urls?.length);
+  const hasTargets = Boolean(body.targets?.length);
+  if (hasUrls === hasTargets) {
+    ctx.addIssue({
+      code: z24.ZodIssueCode.custom,
+      message: "provide exactly one of urls or targets",
+      path: hasUrls ? ["targets"] : ["urls"]
+    });
+  }
+});
 var SerpIntelligenceAICitationSchema = z24.object({
   text: z24.string(),
   href: z24.string()
@@ -15689,14 +15787,24 @@ async function captureSerpIntelligenceSnapshot(rawInput, runtimeOptions = {}) {
     });
     const pageSnapshotLimit = normalizePageSnapshotLimit(parsedInput);
     const pageSnapshotTargets = collectPageSnapshotTargets(harvestResult, pageSnapshotLimit);
-    const pageSnapshotArtifacts = pageSnapshotTargets.length > 0 ? (await capturePageSnapshotsFn(pageSnapshotTargets, {
-      kernelApiKey: runtimeOptions.kernelApiKey ?? browserServiceApiKey(),
-      timeoutMs: runtimeOptions.pageSnapshotTimeoutMs,
-      maxConcurrency: runtimeOptions.pageSnapshotMaxConcurrency,
-      debug,
-      includeContent: runtimeOptions.includePageSnapshotContent,
-      maxContentChars: runtimeOptions.maxPageSnapshotContentChars
-    })).pageSnapshotArtifacts.map(stripPageSnapshotArtifact) : [];
+    const pageSnapshotArtifacts = pageSnapshotTargets.length > 0 ? (await runWithCostContext(
+      {
+        ...currentCostContext() ?? { op: "serp" },
+        subOp: "page_snapshot",
+        // Page snapshot launches have their own fixed product rate. They
+        // must not overwrite the headless/headful mode used to settle the
+        // preceding SERP harvest.
+        headlessSentOut: void 0
+      },
+      () => capturePageSnapshotsFn(pageSnapshotTargets, {
+        kernelApiKey: runtimeOptions.kernelApiKey ?? browserServiceApiKey(),
+        timeoutMs: runtimeOptions.pageSnapshotTimeoutMs,
+        maxConcurrency: runtimeOptions.pageSnapshotMaxConcurrency,
+        debug,
+        includeContent: runtimeOptions.includePageSnapshotContent,
+        maxContentChars: runtimeOptions.maxPageSnapshotContentChars
+      })
+    )).pageSnapshotArtifacts.map(stripPageSnapshotArtifact) : [];
     return normalizeHarvestResultForSerpIntelligence({
       harvestResult,
       attempts,
@@ -15713,6 +15821,7 @@ var SERP_INTELLIGENCE_RATE_LIMIT = 60;
 var SERP_INTELLIGENCE_RATE_WINDOW_SECONDS = 60;
 var POST_CAPTURE_ROUTE_LABEL = "POST /capture";
 var POST_PAGE_SNAPSHOTS_ROUTE_LABEL = "POST /page-snapshots";
+var SERP_CAPTURE_BILLING_SOURCE = "serp_intelligence_capture";
 var serpIntelligenceApp = new Hono16();
 serpIntelligenceApp.use("*", createApiKeyAuth());
 function structuredError(input) {
@@ -15752,18 +15861,46 @@ async function enforceSerpIntelligenceRateLimit(c, userId) {
   );
 }
 function pageSnapshotTargetsFromBody(body) {
-  return body.targets?.length ? body.targets : body.urls.map((url) => ({
+  return body.targets?.length ? body.targets : (body.urls ?? []).map((url) => ({
     url,
     sourceKind: "configured_target",
     sourcePosition: null
   }));
 }
+async function logRequestEventBestEffort(input) {
+  try {
+    await logRequestEvent(input);
+  } catch (error) {
+    console.warn("[serp-intelligence] request audit log failed:", error instanceof Error ? error.message : String(error));
+  }
+}
+function captureBillingKeys(userId, suppliedKey, body) {
+  const responseKey = suppliedKey?.trim() || randomUUID3();
+  const requestFingerprint = createHash4("sha256").update(JSON.stringify(body)).digest("hex");
+  const keyDigest = createHash4("sha256").update(String(userId)).update("\0").update(responseKey).digest("hex");
+  return {
+    responseKey,
+    debitKey: `serp-capture:${userId}:${keyDigest}`,
+    debitDescription: `${body.query} [request:${requestFingerprint}]`
+  };
+}
 serpIntelligenceApp.post("/capture", async (c) => {
   void POST_CAPTURE_ROUTE_LABEL;
   const user = c.get("user");
   const raw = await c.req.json().catch(() => ({}));
   const parsed = SerpIntelligenceCaptureBodySchema.safeParse(raw);
   if (!parsed.success) return c.json(formatZodError(parsed.error), 400);
+  const suppliedIdempotencyKey = c.req.header("idempotency-key") ?? c.req.header("x-idempotency-key");
+  if (suppliedIdempotencyKey && suppliedIdempotencyKey.trim().length > 500) {
+    return c.json(structuredError({
+      error_code: "invalid_request",
+      error_type: "validation_error",
+      message: "Idempotency-Key must be 500 characters or fewer.",
+      retryable: false
+    }), 400);
+  }
+  const billingKeys = captureBillingKeys(user.id, suppliedIdempotencyKey, parsed.data);
+  c.header("Idempotency-Key", billingKeys.responseKey);
   const limited = await enforceSerpIntelligenceRateLimit(c, user.id);
   if (limited) return limited;
   const gate = await acquireConcurrencyGate(user, "serp_intelligence_capture", {
@@ -15771,51 +15908,130 @@ serpIntelligenceApp.post("/capture", async (c) => {
     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;
-  let debited = false;
+  const pageSnapshotHold = parsed.data.includePageSnapshots ? parsed.data.pageSnapshotLimit * MC_COSTS.page_scrape : 0;
+  const cost = MC_COSTS.serp_headful + pageSnapshotHold;
+  const headlessSentOut = { value: null };
   try {
-    const { ok, balance_mc } = await debitMc(
+    const { ok, balance_mc } = await debitMcIdempotent(
       user.id,
       cost,
       LedgerOperation.SERP,
-      parsed.data.query
+      billingKeys.debitDescription,
+      billingKeys.debitKey
     );
-    if (!ok) return c.json(insufficientBalanceResponse(balance_mc, cost), 402);
-    debited = true;
-    const result = await captureSerpIntelligenceSnapshot(parsed.data, {
-      kernelApiKey: browserServiceApiKey(),
-      kernelProxyId: browserServiceProxyId(),
-      signal: c.req.raw.signal,
-      billing: { creditsUsed: cost / MC_PER_CREDIT }
+    if (!ok) {
+      await releaseConcurrencyGate(gate.lockId);
+      return c.json(insufficientBalanceResponse(balance_mc, cost), 402);
+    }
+  } catch (error) {
+    const idempotencyConflict = error instanceof Error && error.message === "idempotent debit key conflicts with another debit";
+    const body = structuredError({
+      error_code: idempotencyConflict ? "idempotency_conflict" : "capture_failed",
+      error_type: idempotencyConflict ? "validation_error" : "capture_error",
+      message: error instanceof Error ? error.message : String(error),
+      retryable: !idempotencyConflict
     });
-    await logRequestEvent({
+    await logRequestEventBestEffort({
       userId: user.id,
-      source: "serp_intelligence_capture",
-      status: "done",
+      source: SERP_CAPTURE_BILLING_SOURCE,
+      status: "failed",
       query: parsed.data.query,
       location: parsed.data.location,
-      resultCount: result.harvestResult.organicResults.length,
-      result
+      error: body.message
     });
-    return c.json(result);
+    await releaseConcurrencyGate(gate.lockId);
+    return c.json(body, idempotencyConflict ? 409 : 500);
+  }
+  let result;
+  try {
+    const parentCostContext = currentCostContext();
+    result = await runWithCostContext(
+      {
+        ...parentCostContext ?? {},
+        op: "serp",
+        userId: Number(user.id),
+        headlessSentOut
+      },
+      () => captureSerpIntelligenceSnapshot(parsed.data, {
+        kernelApiKey: browserServiceApiKey(),
+        kernelProxyId: browserServiceProxyId(),
+        signal: c.req.raw.signal
+      })
+    );
   } catch (error) {
-    if (debited) await creditMc(user.id, cost, LedgerOperation.REFUND, "failed serp intelligence capture");
+    try {
+      await settleDebitMcIdempotent(
+        user.id,
+        billingKeys.debitKey,
+        0,
+        LedgerOperation.SERP_REFUND,
+        "failed serp intelligence capture",
+        SERP_CAPTURE_BILLING_SOURCE
+      );
+    } catch (settlementError) {
+      console.warn(
+        "[serp-intelligence] failed capture refund remains recoverable:",
+        settlementError instanceof Error ? settlementError.message : String(settlementError)
+      );
+    }
     const body = error instanceof SerpIntelligenceCaptureError ? error.toJSON() : structuredError({
       error_code: "capture_failed",
       error_type: "capture_error",
       message: error instanceof Error ? error.message : String(error),
       retryable: true
     });
-    await logRequestEvent({
+    await logRequestEventBestEffort({
       userId: user.id,
-      source: "serp_intelligence_capture",
+      source: SERP_CAPTURE_BILLING_SOURCE,
       status: "failed",
       query: parsed.data.query,
       location: parsed.data.location,
       error: "message" in body && typeof body.message === "string" ? body.message : "SERP Intelligence capture failed"
     });
     const status = error instanceof SerpIntelligenceCaptureError ? error.httpStatus : 500;
+    await releaseConcurrencyGate(gate.lockId);
     return c.json(body, status);
+  }
+  try {
+    const requestedActualCost = serpActualCostMc(headlessSentOut.value) + result.pageSnapshotArtifacts.length * MC_COSTS.page_scrape;
+    const settlement = await settleDebitMcIdempotent(
+      user.id,
+      billingKeys.debitKey,
+      requestedActualCost,
+      LedgerOperation.SERP_REFUND,
+      "SERP capture pricing settle",
+      SERP_CAPTURE_BILLING_SOURCE
+    );
+    const settledResult = {
+      ...result,
+      billing: { creditsUsed: settlement.final_amount_mc / MC_PER_CREDIT }
+    };
+    await logRequestEventBestEffort({
+      userId: user.id,
+      source: SERP_CAPTURE_BILLING_SOURCE,
+      status: "done",
+      query: parsed.data.query,
+      location: parsed.data.location,
+      resultCount: settledResult.harvestResult.organicResults.length,
+      result: settledResult
+    });
+    return c.json(settledResult);
+  } catch (error) {
+    const body = structuredError({
+      error_code: "capture_failed",
+      error_type: "capture_error",
+      message: error instanceof Error ? error.message : String(error),
+      retryable: true
+    });
+    await logRequestEventBestEffort({
+      userId: user.id,
+      source: SERP_CAPTURE_BILLING_SOURCE,
+      status: "failed",
+      query: parsed.data.query,
+      location: parsed.data.location,
+      error: body.message
+    });
+    return c.json(body, 500);
   } finally {
     await releaseConcurrencyGate(gate.lockId);
   }
@@ -15851,7 +16067,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
       maxConcurrency: parsed.data.maxConcurrency,
       debug: parsed.data.debug
     });
-    await logRequestEvent({
+    await logRequestEventBestEffort({
       userId: user.id,
       source: "serp_intelligence_page_snapshots",
       status: "done",
@@ -15868,7 +16084,7 @@ serpIntelligenceApp.post("/page-snapshots", async (c) => {
       message: error instanceof Error ? error.message : String(error),
       retryable: true
     });
-    await logRequestEvent({
+    await logRequestEventBestEffort({
       userId: user.id,
       source: "serp_intelligence_page_snapshots",
       status: "failed",
@@ -16513,15 +16729,42 @@ mcpApp.all("/", async (c) => {
 });
 
 // src/api/browser-agent-routes.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { Hono as Hono18 } from "hono";
 
 // src/api/browser-agent-db.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var _ready = false;
+var _migrationPromise = null;
 async function migrateBrowserAgent() {
   if (_ready) return;
+  if (_migrationPromise) return _migrationPromise;
+  _migrationPromise = runBrowserAgentMigration().finally(() => {
+    _migrationPromise = null;
+  });
+  return _migrationPromise;
+}
+async function runBrowserAgentMigration() {
   const db = getDb();
+  const existing = await db.execute(`
+    SELECT
+      (SELECT COUNT(*) FROM sqlite_master WHERE type = 'table' AND name IN (
+        'browser_agent_sessions',
+        'browser_agent_actions',
+        'browser_agent_replays',
+        'browser_auth_connections',
+        'browser_agent_extensions'
+      )) = 5
+      AND (SELECT COUNT(*) FROM pragma_table_info('browser_agent_sessions') WHERE name = 'concurrency_lock_id') = 1
+      AND (SELECT COUNT(*) FROM pragma_table_info('browser_auth_connections') WHERE name IN (
+        'account_email', 'note', 'updated_at', 'status', 'browser_agent_session_id'
+      )) = 5
+      AS ready
+  `);
+  if (Number(existing.rows[0]?.ready ?? 0) === 1) {
+    _ready = true;
+    return;
+  }
   await db.execute(`
     CREATE TABLE IF NOT EXISTS browser_agent_sessions (
       id                  TEXT PRIMARY KEY,
@@ -16621,7 +16864,7 @@ async function migrateBrowserAgent() {
 }
 async function createExtensionRow(input) {
   const db = getDb();
-  const id = `bext_${randomUUID3().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bext_${randomUUID4().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_agent_extensions (id, user_id, name, backend_id, backend_name, source, source_url, size_bytes)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -16656,7 +16899,7 @@ async function deleteExtensionRow(userId, name) {
 }
 async function createAuthConnectionRow(input) {
   const db = getDb();
-  const connectionId = `authc_${randomUUID3().replace(/-/g, "").slice(0, 20)}`;
+  const connectionId = `authc_${randomUUID4().replace(/-/g, "").slice(0, 20)}`;
   await db.execute({
     sql: `INSERT INTO browser_auth_connections (connection_id, domain, profile, account_email, note, status, browser_agent_session_id)
           VALUES (?, ?, ?, ?, ?, 'NEEDS_AUTH', ?)`,
@@ -16690,7 +16933,7 @@ async function listAuthConnectionsByProfile(profile) {
 }
 async function createSessionRow(input) {
   const db = getDb();
-  const id = `bas_${randomUUID3().replace(/-/g, "").slice(0, 20)}`;
+  const id = `bas_${randomUUID4().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, concurrency_lock_id, last_action_at)
           VALUES (?, ?, ?, ?, 'open', ?, ?, ?, datetime('now'))`,
@@ -16759,7 +17002,7 @@ async function recordAction(input) {
     sql: `INSERT INTO browser_agent_actions (id, session_id, type, params_json, ok, error)
           VALUES (?, ?, ?, ?, ?, ?)`,
     args: [
-      `baa_${randomUUID3().replace(/-/g, "").slice(0, 20)}`,
+      `baa_${randomUUID4().replace(/-/g, "").slice(0, 20)}`,
       input.sessionId,
       input.type,
       input.params == null ? null : JSON.stringify(input.params),
@@ -18447,7 +18690,7 @@ function buildBrowserAgentRoutes() {
     }
     const existing = await getExtensionRow(user.id, name);
     if (existing) return c.json({ error: `an extension named "${name}" already exists \u2014 delete it first or pick another name` }, 409);
-    const backendName = `u${user.id}_${randomUUID4().replace(/-/g, "")}`;
+    const backendName = `u${user.id}_${randomUUID5().replace(/-/g, "")}`;
     try {
       const imported = await importExtensionFromStore(storeUrl, backendName);
       const row = await createExtensionRow({
@@ -18877,7 +19120,7 @@ async function resolveUser(customerId, emailFallback) {
 // src/api/oauth-routes.ts
 import { Hono as Hono20 } from "hono";
 import { getCookie, setCookie } from "hono/cookie";
-import { createHash as createHash4, randomBytes as randomBytes2, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID6 } from "crypto";
 import { importPKCS8, exportJWK, SignJWT } from "jose";
 var ISSUER = "https://mcpscraper.dev";
 var RESOURCE = () => process.env.MCP_MEMORY_RESOURCE_URL ?? "https://memory.mcpscraper.dev/mcp";
@@ -18910,7 +19153,7 @@ async function getKeys() {
   const privateKey = await importPKCS8(pem, "RS256", { extractable: true });
   const full = await exportJWK(privateKey);
   const publicJwk = { kty: full.kty, n: full.n, e: full.e };
-  const kid = createHash4("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
+  const kid = createHash5("sha256").update(JSON.stringify({ e: publicJwk.e, kty: publicJwk.kty, n: publicJwk.n })).digest("base64url").slice(0, 16);
   publicJwk.kid = kid;
   publicJwk.alg = "RS256";
   publicJwk.use = "sig";
@@ -19220,12 +19463,12 @@ oauthApp.post("/oauth/authorize", async (c) => {
 });
 function pkceMatches(verifier, challenge) {
   if (!verifier) return false;
-  const computed = createHash4("sha256").update(verifier).digest("base64url");
+  const computed = createHash5("sha256").update(verifier).digest("base64url");
   return computed === challenge;
 }
 async function mintAccessToken(identity, scope, plan, audience) {
   const { privateKey, kid } = await getKeys();
-  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID5()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
+  return new SignJWT({ scope, plan }).setProtectedHeader({ alg: "RS256", kid }).setIssuer(ISSUER).setSubject(identity).setAudience(audience).setIssuedAt().setJti(randomUUID6()).setExpirationTime(`${ACCESS_TTL_SECONDS}s`).sign(privateKey);
 }
 function tokenErrorResponse(c, error, description, status) {
   return c.json({ error, error_description: description }, status);
@@ -20571,13 +20814,13 @@ import { getCookie as getCookie2, setCookie as setCookie2, deleteCookie } from "
 import Stripe2 from "stripe";
 
 // src/api/page-diff.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash5("sha256").update(value).digest("hex");
+  return createHash6("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -20684,7 +20927,7 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -20714,7 +20957,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash6("sha256").update(value).digest("hex");
+  return createHash7("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -20983,7 +21226,7 @@ async function cleanupExpiredScrapeBlobs(maxAgeMs = SCRAPE_BLOB_TTL_MS) {
 }
 
 // src/api/connected-data-export.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var CONNECTED_DATA_INLINE_BUDGET_BYTES = Number(
   process.env.MCP_SCRAPER_CONNECTED_DATA_INLINE_BUDGET_BYTES ?? 5e4
 );
@@ -21108,7 +21351,7 @@ function finitePositive(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 async function collectConnectedDataExport(args) {
-  const exportId = randomUUID6();
+  const exportId = randomUUID7();
   const now = args.now ?? Date.now;
   const startedAt = now();
   const budgetMs = finitePositive(CONNECTED_DATA_EXPORT_BUDGET_MS, 24e4);
@@ -21220,12 +21463,6 @@ ${lines.length ? `${lines.join("\n")}
 }
 
 // src/api/credit-operations.ts
-async function grantSignupCredit(userId) {
-  if (!FREE_SIGNUP_MC || FREE_SIGNUP_MC <= 0) return;
-  const already = await ledgerExistsForOperation(userId, LedgerOperation.SIGNUP_GRANT);
-  if (already) return;
-  await creditMc(userId, FREE_SIGNUP_MC, LedgerOperation.SIGNUP_GRANT, "Welcome credits");
-}
 async function applyMonthlyFreeRefresh(user) {
   return user;
 }
@@ -21437,7 +21674,7 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 var DEFAULT_NANGO_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
 var DISABLED_NANGO_TOOLS = {
   "google-mail": /* @__PURE__ */ new Set(["list-filters"]),
@@ -22036,7 +22273,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash7("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash8("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   const body = await controlRequest("/api/internal/nango/connections/actions/describe", {
@@ -22637,7 +22874,6 @@ app.use("*", (c, next) => {
   const forceHeadless = c.req.header("x-kernel-headless") === "true";
   return runWithCostContext({ op, probeRunId, forceHeadless }, () => next());
 });
-void migrateCostTelemetry();
 app.post("/auth/register", requireAllowedOrigin, async (c) => {
   const { email, password } = await c.req.json();
   const normalizedEmail = email?.trim().toLowerCase();
@@ -22668,7 +22904,6 @@ app.post("/auth/register", requireAllowedOrigin, async (c) => {
       }
     }
     const newKey = await rotateApiKey(user.id);
-    await grantSignupCredit(user.id);
     void (async () => {
       try {
         const full = await getUserById(user.id);
@@ -22776,11 +23011,7 @@ app.get("/catalog", (c) => {
   return c.json(CATALOG);
 });
 app.get("/rates", (c) => {
-  const costs = CREDIT_COST_CATALOG.map(({ aliases, ...cost }) => ({
-    ...cost,
-    ...cost.notes ? { notes: cost.notes.replace(/ via fal\.ai/g, "") } : {}
-  }));
-  return c.json({ creditsPerDollarStarter: Math.round(1 / 15e-5), costs });
+  return c.json(getPublicRatesPayload());
 });
 app.get("/me", async (c) => {
   const token = getCookie2(c, "session");
@@ -23851,7 +24082,7 @@ app.post("/harvest", auth2, async (c) => {
     serpOnly: body.serpOnly ?? false,
     pages: Math.min(2, Math.max(1, body.pages ?? 1))
   };
-  const harvestCost = options.serpOnly ? MC_COSTS.serp : paaCostForQuestionCount(options.maxQuestions);
+  const harvestCost = options.serpOnly ? MC_COSTS.serp_headful : paaCostForQuestionCount(options.maxQuestions);
   const { ok: harvestOk, balance_mc: harvestBal } = await debitMc(user.id, harvestCost, options.serpOnly ? LedgerOperation.SERP : LedgerOperation.PAA, options.query);
   if (!harvestOk) return c.json(insufficientBalanceResponse(harvestBal, harvestCost), 402);
   const jobId = await createJob(user.id, options.query, { ...options, billingHoldMc: harvestCost }, body.callback_url);
@@ -23887,7 +24118,7 @@ app.post("/harvest/sync", auth2, async (c) => {
     serpOnly: body.serpOnly ?? false,
     pages: Math.min(2, Math.max(1, body.pages ?? 1))
   };
-  const syncCost = options.serpOnly ? MC_COSTS.serp : paaCostForQuestionCount(options.maxQuestions);
+  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);
   if (!syncOk) return c.json(insufficientBalanceResponse(syncBal, syncCost), 402);
   const jobId = await createRunningJob(user.id, options.query, options);
@@ -23897,10 +24128,11 @@ app.post("/harvest/sync", auth2, async (c) => {
     c.req.raw.signal,
     AbortSignal.timeout(syncTimeoutMs)
   ]);
+  const headlessSentOut = { value: null };
   try {
     const harvestCtx = currentCostContext();
     const result = await runWithCostContext(
-      { ...harvestCtx, op: options.serpOnly ? "serp" : "paa", userId: user.id },
+      { ...harvestCtx, op: options.serpOnly ? "serp" : "paa", userId: user.id, headlessSentOut },
       () => harvest({
         ...options,
         kernelApiKey: browserServiceApiKey(),
@@ -23919,6 +24151,11 @@ app.post("/harvest/sync", auth2, async (c) => {
       const diff = syncCost - actualCost;
       if (diff > 0) await creditMc(user.id, diff, LedgerOperation.PAA_REFUND, "overestimate refund");
       else if (diff < 0) await debitMc(user.id, -diff, LedgerOperation.PAA, options.query);
+    } else {
+      const actualCost = serpActualCostMc(headlessSentOut.value);
+      const diff = syncCost - actualCost;
+      if (diff > 0) await creditMc(user.id, diff, LedgerOperation.SERP_REFUND, "headless-mode pricing settle");
+      else if (diff < 0) await debitMc(user.id, -diff, LedgerOperation.SERP, options.query);
     }
     return c.json({ job_id: jobId, status: "done", result: sanitizeHarvestResult(result), attempts: sanitizeAttempts(attempts) });
   } catch (err) {
@@ -23994,22 +24231,13 @@ app.delete("/admin/users/:id", adminAuth, async (c) => {
 });
 app.post("/admin/backfill-signup-credits", adminAuth, async (c) => {
   const users = await listUsers();
-  let processed = 0;
-  let credited = 0;
-  let skipped = 0;
-  const users_credited = [];
-  for (const user of users) {
-    processed++;
-    const alreadyHasGrant = await ledgerExistsForOperation(user.id, LedgerOperation.SIGNUP_GRANT);
-    if (alreadyHasGrant) {
-      skipped++;
-    } else {
-      await grantSignupCredit(user.id);
-      credited++;
-      users_credited.push({ id: user.id, email: user.email });
-    }
-  }
-  return c.json({ processed, credited, skipped, users_credited });
+  return c.json({
+    processed: users.length,
+    credited: 0,
+    skipped: users.length,
+    users_credited: [],
+    retired: true
+  });
 });
 app.post("/extract-url", auth2, async (c) => {
   const raw = await c.req.json().catch(() => ({}));
@@ -24590,7 +24818,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-GE5JMHE6.js");
+  const { drainQueue } = await import("./worker-RV2TYXE3.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([
@@ -24618,15 +24846,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-5V5EEQ72.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-HMCYUVBJ.js");
+  const { getExtractJob: getExtractJob2, completeExtractJob: completeExtractJob2 } = await import("./site-extract-repository-2QQSL2QC.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-NFFVMUMT.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-5V5EEQ72.js");
+    const { settleExtractJob: settleExtractJob2, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-2QQSL2QC.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -24792,4 +25020,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-CHTX6YQA.js.map
+//# sourceMappingURL=server-OLOOFN5W.js.map