bereach-openclaw 1.5.0-beta.2 → 1.5.0-beta.3

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "bereach-openclaw",
   "name": "BeReach",
-  "version": "1.5.0-beta.2",
+  "version": "1.5.0-beta.3",
   "description": "LinkedIn outreach automation — 75+ tools, hook-based enforcement, dynamic context",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bereach-openclaw",
-  "version": "1.5.0-beta.2",
+  "version": "1.5.0-beta.3",
   "description": "BeReach LinkedIn automation plugin for OpenClaw",
   "license": "AGPL-3.0",
   "exports": {
@@ -32,7 +32,10 @@
     "test:e2e:check-regression": "tsx __tests__/e2e/lib/token-tracker.ts --check-regression",
     "test:e2e:upgrade-setup": "cd __tests__/docker && docker compose -f docker-compose.upgrade-test.yml up -d --build",
     "test:e2e:upgrade-teardown": "cd __tests__/docker && docker compose -f docker-compose.upgrade-test.yml down",
-    "test:e2e:upgrade": "cd __tests__/docker && ./upgrade-test.sh"
+    "test:e2e:upgrade": "cd __tests__/docker && ./upgrade-test.sh",
+    "test:e2e:vps-setup": "cd __tests__/docker && docker compose -f docker-compose.vps-test.yml up -d --build",
+    "test:e2e:vps-teardown": "cd __tests__/docker && docker compose -f docker-compose.vps-test.yml down",
+    "test:e2e:vps-smoke": "cd __tests__/docker && ./vps-smoke-test.sh"
   },
   "openclaw": {
     "extensions": [

package/src/commands/connector.ts

@@ -61,6 +61,86 @@ type TaskResult = {
 
 const MIN_POLL_MS = 5000;
 
+// ---------------------------------------------------------------------------
+// TaskResult extraction from OpenClaw agent output
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the last JSON block from agent output text.
+ * Copied from lifecycle.ts — the connector must be self-contained
+ * since it can run as a standalone CLI without lifecycle hooks.
+ */
+function parseStructuredResult(text: string): Record<string, unknown> | null {
+  // Try fenced code blocks first
+  const jsonBlocks = text.match(/```(?:json)?\s*([\s\S]*?)```/g);
+  if (jsonBlocks?.length) {
+    const lastBlock = jsonBlocks[jsonBlocks.length - 1];
+    const jsonStr = lastBlock.replace(/^```(?:json)?\s*/, "").replace(/```$/, "").trim();
+    try {
+      return JSON.parse(jsonStr);
+    } catch { /* fall through */ }
+  }
+
+  // Try raw JSON at end of text
+  const lastBrace = text.lastIndexOf("{");
+  if (lastBrace >= 0) {
+    try {
+      return JSON.parse(text.slice(lastBrace));
+    } catch { /* fall through */ }
+  }
+
+  return null;
+}
+
+/**
+ * Extract a TaskResult from OpenClaw --json wrapper output.
+ * OpenClaw wraps agent output as: { result: { payloads: [{text: "..."}], meta: {...} } }
+ * or sometimes: { payloads: [{text: "..."}], meta: {...} }
+ * The actual TaskResult JSON is embedded in the last payload's text field.
+ */
+function extractTaskResultFromWrapper(output: Record<string, unknown>): TaskResult | null {
+  const payloads = (
+    (output?.result as Record<string, unknown>)?.payloads ??
+    output?.payloads ??
+    []
+  ) as { text?: string }[];
+
+  if (payloads.length === 0) return null;
+
+  // Walk payloads backwards — TaskResult JSON is typically in the last one
+  for (let i = payloads.length - 1; i >= 0; i--) {
+    const text = payloads[i]?.text;
+    if (text) {
+      const parsed = parseStructuredResult(text);
+      if (parsed && ("success" in parsed || "contactsProcessed" in parsed)) {
+        return parsed as TaskResult;
+      }
+    }
+  }
+
+  return null;
+}
+
+/** Stderr patterns that are noise (module warnings, not actual errors) */
+const HARMLESS_STDERR_RE = [
+  /Cannot find module '@aws-sdk\/client-bedrock'/,
+  /Cannot find module 'amazon-bedrock'/,
+  /Require stack:/,
+  /ExperimentalWarning/,
+  /DEP\d+/,
+];
+
+function filterStderr(raw: string): string {
+  return raw
+    .split("\n")
+    .filter((line) => {
+      const t = line.trim();
+      return t && !HARMLESS_STDERR_RE.some((p) => p.test(t));
+    })
+    .join("\n")
+    .trim();
+}
+
 function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   return new Promise((resolve) => {
     const delay = Math.max(MIN_POLL_MS, ms);
@@ -96,7 +176,7 @@ async function pullTask(config: ConnectorConfig): Promise<PullResponse> {
   if (!config.apiKey && config.connectorToken) {
     body.connectorToken = config.connectorToken;
   }
-  return httpPost(`${config.apiUrl}/api/tasks/pull`, body, headers) as Promise<PullResponse>;
+  return httpPost(`${config.apiUrl}/tasks/pull`, body, headers) as Promise<PullResponse>;
 }
 
 async function submitResult(
@@ -110,7 +190,7 @@ async function submitResult(
   if (!config.apiKey && config.connectorToken) {
     body.connectorToken = config.connectorToken;
   }
-  await httpPost(`${config.apiUrl}/api/tasks/${taskId}/result`, body, headers);
+  await httpPost(`${config.apiUrl}/tasks/${taskId}/result`, body, headers);
 }
 
 async function heartbeat(
@@ -122,7 +202,7 @@ async function heartbeat(
   if (!config.apiKey && config.connectorToken) {
     body.connectorToken = config.connectorToken;
   }
-  return httpPost(`${config.apiUrl}/api/connectors/heartbeat`, body, headers) as Promise<{ pollIntervalMs: number }>;
+  return httpPost(`${config.apiUrl}/connectors/heartbeat`, body, headers) as Promise<{ pollIntervalMs: number }>;
 }
 
 /**
@@ -161,6 +241,25 @@ async function isWebhookAvailable(config: ConnectorConfig): Promise<boolean> {
   }
 }
 
+/**
+ * Probe webhook with retries — gateway may still be starting (B9 fix).
+ */
+async function probeWebhookWithRetry(
+  config: ConnectorConfig,
+  attempts = 3,
+  delayMs = 2000,
+): Promise<boolean> {
+  for (let i = 1; i <= attempts; i++) {
+    const ok = await isWebhookAvailable(config);
+    if (ok) return true;
+    if (i < attempts) {
+      console.log(`[connector] Webhook probe ${i}/${attempts} failed, retrying in ${delayMs / 1000}s...`);
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  return false;
+}
+
 /**
  * Execute a task via the gateway /hooks/agent webhook.
  * This is the preferred execution path - uses OpenClaw's native agent runner
@@ -251,17 +350,27 @@ async function executeViaExecFile(
   task: NonNullable<PullResponse["task"]>,
 ): Promise<{ result: TaskResult | null; error: string | null }> {
   try {
+    // Use task ID as session ID. The sessionKey ("hook:{userId}:{campaignId}:{type}")
+    // contains colons which the gateway rejects as invalid session IDs.
+    // Task metadata is passed via TASK_META in the message instead.
     const sessionId = `task-${task.id}`;
-    const message = task.message || `Execute ${task.type} task`;
+    const maxCredits = (task.payload as Record<string, unknown>)?.maxCredits ?? 100;
+
+    // The `openclaw agent` CLI connects to the gateway process via WebSocket,
+    // so env vars set here do NOT reach the gateway's plugin hooks.
+    // Instead, inject [TASK_META: ...] into the message so the gateway's
+    // init_context hook can parse task metadata from the prompt text.
+    const taskMeta = `[TASK_META: taskType=${task.type} taskId=${task.id} campaignId=${task.campaignId ?? ""} maxCredits=${maxCredits}]`;
+    const baseMessage = task.message || `Execute ${task.type} task`;
+    const message = `${taskMeta}\n\n${baseMessage}`;
 
-    // Pass task metadata via environment variables so the plugin's
-    // detectTaskMode() picks them up without needing the hook: session prefix
+    // Keep env vars for --local mode (direct execution without gateway)
     const env: Record<string, string> = {
       ...process.env as Record<string, string>,
       BEREACH_TASK_ID: task.id,
       BEREACH_TASK_TYPE: task.type,
       BEREACH_TASK_CAMPAIGN_ID: task.campaignId ?? "",
-      BEREACH_TASK_MAX_CREDITS: String((task.payload as Record<string, unknown>)?.maxCredits ?? 100),
+      BEREACH_TASK_MAX_CREDITS: String(maxCredits),
     };
 
     const args = [
@@ -297,12 +406,22 @@ async function executeViaExecFile(
       if (output.error) {
         return { result: null, error: output.error };
       }
-      // The lifecycle hook posts the structured result to the API directly,
-      // but we also parse it here as a fallback
-      return {
-        result: output.result ?? { success: true },
-        error: null,
-      };
+
+      // OpenClaw --json wraps agent output in { result: { payloads: [...], meta: {...} } }
+      // The actual TaskResult is embedded in the last payload's text.
+      // B17 fix: extract it instead of returning the raw wrapper.
+      const extracted = extractTaskResultFromWrapper(output);
+      if (extracted) {
+        return { result: extracted, error: null };
+      }
+
+      // Fallback: if output itself looks like a flat TaskResult
+      if (output.success !== undefined || output.contactsProcessed !== undefined) {
+        return { result: output as TaskResult, error: null };
+      }
+
+      // Last resort: lifecycle hook may have already posted the real result
+      return { result: { success: true }, error: null };
     } catch {
       // Non-JSON output - treat as success if process exited cleanly
       return {
@@ -323,15 +442,26 @@ async function executeViaExecFile(
     if (stdout) {
       try {
         const output = JSON.parse(stdout);
-        if (output.result) {
-          return { result: output.result, error: null };
+        if (output.error) {
+          return { result: null, error: String(output.error).slice(0, 500) };
+        }
+        // B17 fix: extract TaskResult from OpenClaw wrapper (same as happy path)
+        const extracted = extractTaskResultFromWrapper(output);
+        if (extracted) {
+          return { result: extracted, error: null };
+        }
+        // Accept flat { success: true } format
+        if (output.success !== undefined || output.contactsProcessed !== undefined) {
+          return { result: output as TaskResult, error: null };
         }
       } catch {
         // Not JSON
       }
     }
 
-    const message = stderr || execErr.message || String(err);
+    // Filter known-harmless stderr noise (e.g. @aws-sdk/client-bedrock module warnings)
+    const filtered = filterStderr(stderr);
+    const message = filtered || execErr.message || String(err);
     return { result: null, error: message.slice(0, 500) };
   }
 }
@@ -361,7 +491,7 @@ async function updateTaskStatus(
   if (!config.apiKey && config.connectorToken) {
     body.connectorToken = config.connectorToken;
   }
-  await httpPost(`${config.apiUrl}/api/tasks/${taskId}/result`, body, headers).catch((err) => {
+  await httpPost(`${config.apiUrl}/tasks/${taskId}/result`, body, headers).catch((err) => {
     console.error(`[connector] Task status update to "${status}" failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
   });
 }
@@ -392,8 +522,8 @@ export async function runConnectorLoop(
   console.log(`[connector] API: ${config.apiUrl}`);
   console.log(`[connector] Auth: ${config.apiKey ? "API key (Bearer)" : "connector token (legacy)"}`);
 
-  // Probe webhook availability on startup
-  webhookAvailable = await isWebhookAvailable(config);
+  // Probe webhook availability on startup (with retry for gateway startup race — B9 fix)
+  webhookAvailable = await probeWebhookWithRetry(config);
   const execMode = webhookAvailable ? "webhook" : "execFile (fallback)";
   console.log(`[connector] Execution mode: ${execMode}`);
   if (webhookAvailable) {
@@ -462,13 +592,15 @@ export async function runConnectorLoop(
             webhookAvailable,
           );
 
+          const taskStatus = error ? "failed" : (result?.success !== false ? "succeeded" : "failed");
           console.log(
-            `[connector] Task ${response.task.id} ${result?.success ? "succeeded" : "failed"}`,
+            `[connector] Task ${response.task.id} ${taskStatus}${error ? `: ${error.slice(0, 100)}` : ""}`,
           );
 
           // With webhook execution, the lifecycle hook auto-reports results.
           // Submit from connector for execFile fallback, errors, or as safety net
           // when lifecycle hook may not have fired (agent crash).
+          // Don't submit if result looks successful — lifecycle hook already posted.
           if (!webhookAvailable || error) {
             await submitResult(config, response.task.id, result, error);
           }
@@ -497,6 +629,15 @@ export async function runConnectorLoop(
         config.pollIntervalMs * Math.pow(2, consecutiveErrors),
         5 * 60 * 1000,
       );
+
+      // Re-probe webhook if stuck in execFile mode with repeated errors (B9 fix)
+      if (!webhookAvailable && consecutiveErrors >= 3 && consecutiveErrors % 3 === 0) {
+        console.log(`[connector] ${consecutiveErrors} consecutive errors, re-probing webhook...`);
+        webhookAvailable = await isWebhookAvailable(config);
+        if (webhookAvailable) {
+          console.log(`[connector] Webhook now available, switching to webhook mode`);
+        }
+      }
     }
 
     await sleep(pollInterval, signal);

package/src/commands/index.ts

@@ -9,7 +9,7 @@ export function registerCommands(api: any, state?: SessionState, apiKey?: string
     name: "bereach-credits",
     description: "Show current BeReach credit balance",
     handler: async () => {
-      const res = await apiFetch<{ credits: { current: number; limit: number | null; remaining: number | null; isUnlimited: boolean; percentage: number } }>("/api/me/credits", resolvedKey);
+      const res = await apiFetch<{ credits: { current: number; limit: number | null; remaining: number | null; isUnlimited: boolean; percentage: number } }>("/me/credits", resolvedKey);
       if (!res) return { text: "Failed to fetch credits." };
       const c = res.credits;
       return {
@@ -24,7 +24,7 @@ export function registerCommands(api: any, state?: SessionState, apiKey?: string
     name: "bereach-status",
     description: "Show LinkedIn rate limit summary",
     handler: async () => {
-      const res = await apiFetch<any>("/api/rate-limits", resolvedKey);
+      const res = await apiFetch<any>("/rate-limits", resolvedKey);
       if (!res) return { text: "Failed to fetch limits." };
       const limits = res?.linkedIn?.limits ?? res?.limits ?? {};
       const lines = ["BeReach Rate Limits:"];

package/src/commands/setup.ts

@@ -31,7 +31,7 @@ export function registerSetupCommand(api: any) {
 
         // Validate key by calling a lightweight endpoint
         try {
-          const res = await fetch(`${API_BASE}/api/me/credits`, {
+          const res = await fetch(`${API_BASE}/me/credits`, {
             headers: { Authorization: `Bearer ${apiKey}` },
             signal: AbortSignal.timeout(5000),
           });

package/src/connector/manager.ts

@@ -52,7 +52,7 @@ class ConnectorManager {
         if (taskId && this.config?.apiKey) {
           console.log(`[bereach:connector] reporting task ${taskId} as interrupted...`);
           try {
-            await fetch(`${this.config.apiUrl}/api/tasks/${taskId}/result`, {
+            await fetch(`${this.config.apiUrl}/tasks/${taskId}/result`, {
               method: "POST",
               headers: {
                 "Authorization": `Bearer ${this.config.apiKey}`,

package/src/connector-cli.ts

@@ -37,7 +37,7 @@ async function gracefulShutdown(signal: string) {
     try {
       const headers: Record<string, string> = { "Content-Type": "application/json" };
       if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
-      await fetch(`${config.apiUrl}/api/tasks/${taskId}/result`, {
+      await fetch(`${config.apiUrl}/tasks/${taskId}/result`, {
         method: "POST",
         headers,
         body: JSON.stringify({ result: null, error: `Connector terminated (${signal})` }),

package/src/hooks/cache.ts

@@ -219,7 +219,7 @@ export { apiFetchUtil as apiFetch };
 // ---------------------------------------------------------------------------
 
 export async function fetchSnapshot(apiKey: string): Promise<CacheStore> {
-  const snapshot = await apiFetchUtil<any>("/api/agent/snapshot", apiKey);
+  const snapshot = await apiFetchUtil<any>("/agent/snapshot", apiKey);
 
   if (!snapshot) {
     log("fetchSnapshot: FAIL — snapshot endpoint returned null");
@@ -255,7 +255,7 @@ export async function fetchSnapshot(apiKey: string): Promise<CacheStore> {
   // Fallback: if snapshot didn't include limits, fetch from dedicated endpoint
   if (!store.limits) {
     log("fetchSnapshot: limits missing from snapshot, fetching from /api/me/limits");
-    const limitsData = await apiFetchUtil<CachedLimits>("/api/me/limits", apiKey);
+    const limitsData = await apiFetchUtil<CachedLimits>("/me/limits", apiKey);
     if (limitsData) {
       store.limits = limitsData;
       log(`fetchSnapshot: limits fallback OK — multiplier=${limitsData.multiplier ?? 1} actions=${Object.keys(limitsData.limits ?? {}).length}`);

package/src/hooks/context.ts

@@ -43,6 +43,7 @@ export function resetProfileState(state: SessionState) {
   state.profileInitDone = false;
   state.toneInferenceInjected = false;
   state.onboardingDirectiveInjected = false;
+  state.anthropicKeyWarningInjected = false;
 }
 
 // Version check cache
@@ -154,7 +155,7 @@ async function fetchSoulTemplate(apiKey?: string): Promise<string> {
   try {
     const headers: Record<string, string> = {};
     if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
-    const res = await fetch(`${API_BASE}/api/onboarding/soul`, {
+    const res = await fetch(`${API_BASE}/onboarding/soul`, {
       headers,
       signal: AbortSignal.timeout(3000),
     });
@@ -194,7 +195,7 @@ async function _autoInitProfileInner(data: CacheStore, apiKey: string): Promise<
       profileUrl?: string;
       linkedinEmail?: string;
       profileData?: { location?: string; connectionsCount?: number };
-    }>("/api/me/linkedin", apiKey);
+    }>("/me/linkedin", apiKey);
 
     if (!profile?.linkedinName) return;
 
@@ -211,7 +212,7 @@ async function _autoInitProfileInner(data: CacheStore, apiKey: string): Promise<
       return;
     }
 
-    await sharedApiFetch("/api/context", apiKey, {
+    await sharedApiFetch("/context", apiKey, {
       method: "PUT",
       body: { type: "user-profile", content, scope: "user" },
     });
@@ -223,7 +224,7 @@ async function _autoInitProfileInner(data: CacheStore, apiKey: string): Promise<
     else data.contexts.push(entry);
 
     // Save refresh timestamp
-    await sharedApiFetch("/api/agent-state/session-meta", apiKey, {
+    await sharedApiFetch("/agent-state/session-meta", apiKey, {
       method: "PATCH",
       body: { data: { lastProfileRefreshAt: new Date().toISOString() } },
     });
@@ -421,7 +422,7 @@ function formatOnboardingDirective(state: SessionState, data: CacheStore, apiKey
     cacheSet("onboardingState", completedState);
 
     if (apiKey) {
-      sharedApiFetch("/api/agent-state/onboarding", apiKey, {
+      sharedApiFetch("/agent-state/onboarding", apiKey, {
         method: "PUT",
         body: {
           data: { completed: true, completedAt: new Date().toISOString(), autoCompleted: true },

package/src/hooks/enforcement.ts

@@ -333,7 +333,7 @@ async function guardScheduledDm(toolName: string, params: Record<string, unknown
 
   try {
     const res = await fetch(
-      `${API_BASE}/api/contacts/${encodeURIComponent(contactId)}`,
+      `${API_BASE}/contacts/${encodeURIComponent(contactId)}`,
       {
         headers: { Authorization: `Bearer ${key}` },
         signal: AbortSignal.timeout(3000),
@@ -382,7 +382,7 @@ async function guardDoNotContact(toolName: string, params: Record<string, unknow
     let contactData: any = null;
     if (effectiveProfile) {
       const res = await fetch(
-        `${API_BASE}/api/contacts/by-url?linkedinUrl=${encodeURIComponent(effectiveProfile)}`,
+        `${API_BASE}/contacts/by-url?linkedinUrl=${encodeURIComponent(effectiveProfile)}`,
         {
           headers: { Authorization: `Bearer ${key}` },
           signal: AbortSignal.timeout(3000),
@@ -395,7 +395,7 @@ async function guardDoNotContact(toolName: string, params: Record<string, unknow
       }
     } else if (contactId) {
       const res = await fetch(
-        `${API_BASE}/api/contacts/${encodeURIComponent(contactId)}`,
+        `${API_BASE}/contacts/${encodeURIComponent(contactId)}`,
         {
           headers: { Authorization: `Bearer ${key}` },
           signal: AbortSignal.timeout(3000),
@@ -479,33 +479,36 @@ function guardBulkInChat(toolName: string, params: Record<string, unknown>, stat
     ?? (typeof params.postUrn === "string" ? params.postUrn : null);
   if (!contactId) { log(`bulk-in-chat: SKIP ${toolName} (no contactId, params=${JSON.stringify(Object.keys(params))})`); return null; }
 
-  // Track this contact
+  // Check limit BEFORE adding to set — otherwise the blocked contact
+  // ends up in the set, inflating the count even though it was never processed.
+  const isNewContact = !state.targetedContacts.has(contactId);
+  if (isNewContact && state.targetedContacts.size >= MAX_CONTACTS_IN_CHAT) {
+    log(`bulk-in-chat BLOCKED ${toolName}: ${state.targetedContacts.size} unique contacts already targeted (max ${MAX_CONTACTS_IN_CHAT})`);
+    return {
+      blocked: true,
+      message: `BLOCKED — ${toolName} not executed. ${MAX_CONTACTS_IN_CHAT} contacts processed. Stop all tool calls. Propose campaign for remaining contacts. Do NOT say remaining were processed.`,
+    };
+  }
+
+  // Track after check passes — only contacts that actually get processed
   state.targetedContacts.add(contactId);
   log(`bulk-in-chat: ${toolName} target=${contactId} unique=${state.targetedContacts.size}/${MAX_CONTACTS_IN_CHAT}`);
-
-  // Allow up to MAX_CONTACTS_IN_CHAT unique contacts
-  if (state.targetedContacts.size <= MAX_CONTACTS_IN_CHAT) return null;
-
-  log(`bulk-in-chat BLOCKED ${toolName}: ${state.targetedContacts.size} unique contacts targeted (max ${MAX_CONTACTS_IN_CHAT})`);
-  const remaining = state.targetedContacts.size - MAX_CONTACTS_IN_CHAT;
-  return {
-    blocked: true,
-    message: `BLOCKED — ${toolName} not executed. ${MAX_CONTACTS_IN_CHAT} contacts processed, ${remaining} remain. Stop all tool calls. Propose campaign for remaining contacts. Do NOT say remaining were processed.`,
-  };
+  return null;
 }
 
 const MAX_POSTS_PER_SESSION = 3;
 
 function guardPostLimit(toolName: string, state: SessionState) {
   if (toolName !== "bereach_publish_post") return null;
-  state.postsThisSession++;
-  if (state.postsThisSession > MAX_POSTS_PER_SESSION) {
+  if (state.postsThisSession >= MAX_POSTS_PER_SESSION) {
     log(`post limit BLOCKED: ${state.postsThisSession}/${MAX_POSTS_PER_SESSION} this session`);
     return {
       blocked: true,
       message: `BLOCKED: Post limit reached (${MAX_POSTS_PER_SESSION} posts per session). Publishing too many posts in a short time can trigger LinkedIn restrictions.`,
     };
   }
+  // Increment AFTER check passes — blocked calls shouldn't inflate the counter
+  state.postsThisSession++;
   return null;
 }
 
@@ -558,6 +561,11 @@ export function registerEnforcementHook(
   // Per-session DM guard mutex (scoped to this hook registration's closure)
   const guardDmPacingAndDedup = createDmGuard();
 
+  // Scrape serialization lock — when OpenClaw batches parallel tool calls,
+  // each before_tool_call fires concurrently. Without serialization, all scrape
+  // calls hit the API simultaneously and trip the minInterval rate limit (B13 fix).
+  let scrapeLock: Promise<void> = Promise.resolve();
+
   // Reset per-turn counters at the start of each agent turn.
   api.on("before_prompt_build", () => {
     state.toolCallCount = 0;
@@ -648,8 +656,12 @@ export function registerEnforcementHook(
     if (toolName === "bereach_bulk_visit_profiles") {
       log(`pacing: SKIP for ${toolName} (server-side via Workflow)`);
     } else if (isRead) {
-      log(`pacing: read delay ${readMin}-${readMax}s for ${toolName}`);
-      await randomDelay(readMin, readMax);
+      // Serialize scrape-type reads through a promise chain so parallel batched
+      // calls don't all hit the API simultaneously (B13 fix)
+      const prev = scrapeLock;
+      scrapeLock = prev.then(() => randomDelay(readMin, readMax));
+      log(`pacing: read delay ${readMin}-${readMax}s for ${toolName} (serialized)`);
+      await scrapeLock;
     } else if (isWrite || PACED_FREE_TOOLS.has(toolName)) {
       log(`pacing: write delay ${writeMin}-${writeMax}s for ${toolName}`);
       await randomDelay(writeMin, writeMax);