@leadbay/mcp 0.2.1 → 0.3.0

package/dist/{chunk-BGJ6JWIO.js → chunk-NED7ATJI.js}

@@ -17,7 +17,7 @@ function httpsRequest(method, url, headers, body) {
     const start = Date.now();
     const parsed = new URL(url);
     const reqHeaders = { ...headers };
-    if (body) {
+    if (body !== void 0) {
       reqHeaders["Content-Length"] = Buffer.byteLength(body);
     }
     const req = https.request({
@@ -39,7 +39,7 @@ function httpsRequest(method, url, headers, body) {
       });
     });
     req.on("error", reject);
-    if (body)
+    if (body !== void 0)
       req.write(body);
     req.end();
   });
@@ -52,6 +52,14 @@ function createClient(config = {}) {
   }
   return new LeadbayClient(baseUrl, config.token, region);
 }
+function formatLoginError(status, body, baseUrl) {
+  const trimmed = body.trim();
+  const head = `login failed (${status}) at ${baseUrl}`;
+  const hint = status === 401 ? " (wrong email or password?)" : status === 429 ? " (rate-limited; wait and retry)" : status >= 500 ? " (server error; try again shortly)" : "";
+  if (!trimmed)
+    return head + hint;
+  return `${head}: ${trimmed.slice(0, 200)}${hint}`;
+}
 async function resolveRegion(email, password, startWith = "us") {
   const order = startWith === "fr" ? ["fr", "us"] : ["us", "fr"];
   let lastErr = null;
@@ -71,12 +79,13 @@ async function resolveRegion(email, password, startWith = "us") {
           };
         }
       }
-      lastErr = { status: res.status, body: res.body, region };
+      lastErr = { kind: "http", status: res.status, body: res.body, region, baseUrl };
     } catch (e) {
-      lastErr = { error: e, region };
+      lastErr = { kind: "network", error: e, region, baseUrl };
     }
   }
-  throw new Error(`Leadbay login failed in both regions (us, fr). Last response: ${JSON.stringify(lastErr)}`);
+  const detail = lastErr?.kind === "http" ? formatLoginError(lastErr.status, lastErr.body, lastErr.baseUrl) : lastErr?.kind === "network" ? `network error at ${lastErr.baseUrl}: ${lastErr.error?.message ?? String(lastErr.error)}` : "no attempts made";
+  throw new Error(`Leadbay login failed in both regions (us, fr). ${detail}`);
 }
 var _mockFixtures = null;
 var _mockJournal = [];
@@ -240,7 +249,7 @@ var LeadbayClient = class {
       return this.mockRequest(method, path, body);
     }
     if (!this.token) {
-      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN env var (obtain token at https://app.leadbay.ai/settings/api-tokens), or use the OpenClaw leadbay_login tool", path);
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN in your MCP client config, or run: npx -y @leadbay/mcp install --email <you> --region <us|fr>", path);
     }
     await this.acquireSemaphore();
     try {
@@ -275,7 +284,7 @@ var LeadbayClient = class {
       return;
     }
     if (!this.token) {
-      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN env var (obtain token at https://app.leadbay.ai/settings/api-tokens), or use the OpenClaw leadbay_login tool", path);
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN in your MCP client config, or run: npx -y @leadbay/mcp install --email <you> --region <us|fr>", path);
     }
     await this.acquireSemaphore();
     try {
@@ -300,6 +309,43 @@ var LeadbayClient = class {
       this.releaseSemaphore();
     }
   }
+  // Like request(), but the caller supplies the Content-Type and the already-
+  // serialized body (string for text payloads such as CSV; Buffer for binary
+  // uploads). Auth, semaphore, error mapping, _lastMeta, and mock-mode all
+  // mirror request() exactly. Used by leadbay_import_leads to upload CSVs to
+  // the wizard at POST /1.5/imports.
+  async requestRawBinary(method, path, contentType, body) {
+    if (process.env.LEADBAY_MOCK === "1") {
+      return this.mockRequestBinary(method, path, contentType, body);
+    }
+    if (!this.token) {
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN in your MCP client config, or run: npx -y @leadbay/mcp install --email <you> --region <us|fr>", path);
+    }
+    await this.acquireSemaphore();
+    try {
+      const url = `${this._baseUrl}/1.5${path}`;
+      const headers = {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": contentType
+      };
+      const res = await httpsRequest(method, url, headers, body);
+      this._lastMeta = {
+        region: this._region,
+        endpoint: `${method} ${path}`,
+        latency_ms: res.latency_ms,
+        retry_after: parseRetryAfter(res.headers["retry-after"])
+      };
+      if (res.status === 204) {
+        return null;
+      }
+      if (res.status < 200 || res.status >= 300) {
+        throw this.mapErrorResponse(res.status, res.body, path, res.headers);
+      }
+      return JSON.parse(res.body);
+    } finally {
+      this.releaseSemaphore();
+    }
+  }
   mockRequest(method, path, body) {
     const fullPath = `/1.5${path}`;
     this._lastMeta = {
@@ -323,6 +369,39 @@ var LeadbayClient = class {
       would_call: { method, path: fullPath, body }
     };
   }
+  mockRequestBinary(method, path, contentType, body) {
+    const fullPath = `/1.5${path}`;
+    this._lastMeta = {
+      region: this._region,
+      endpoint: `${method} ${path}`,
+      latency_ms: 0,
+      retry_after: null
+    };
+    if (method === "GET") {
+      const fixture = findMockFixture("GET", fullPath);
+      if (!fixture) {
+        throw this.makeError("MOCK_NOT_FOUND", `LEADBAY_MOCK=1: no fixture for GET ${path}`, `Add a fixture to LEADBAY_MOCK_DIR (default: ./.context/leadbay-live-shapes/) \u2014 run a probe script to generate one.`, path);
+      }
+      if (fixture.status === 204)
+        return null;
+      return fixture.body;
+    }
+    const journalBody = {
+      _binary: true,
+      length: Buffer.byteLength(body),
+      content_type: contentType
+    };
+    _mockJournal.push({
+      method,
+      path: fullPath,
+      body: journalBody,
+      ts: Date.now()
+    });
+    return {
+      mocked: true,
+      would_call: { method, path: fullPath, body: journalBody }
+    };
+  }
   mapErrorResponse(status, rawBody, endpoint, headers) {
     let parsed;
     try {
@@ -332,7 +411,7 @@ var LeadbayClient = class {
     }
     const retryAfter = parseRetryAfter(headers["retry-after"]);
     if (status === 401) {
-      return this.makeError("AUTH_EXPIRED", "Authentication token expired or invalid", "Your LEADBAY_TOKEN is no longer valid. Regenerate at https://app.leadbay.ai/settings/api-tokens and restart.", endpoint);
+      return this.makeError("AUTH_EXPIRED", "Authentication token expired or invalid", "Your LEADBAY_TOKEN is no longer valid. Regenerate it: npx -y @leadbay/mcp login --email <you> --region <us|fr>, then restart your MCP client.", endpoint);
     }
     if (status === 429 || status === 402 || parsed?.error === "quota_exceeded" || parsed?.error?.code === "quota_exceeded") {
       return this.makeError("QUOTA_EXCEEDED", retryAfter ? `Quota exceeded \u2014 retry in ${retryAfter}s` : "Quota exceeded", retryAfter ? `Wait ${retryAfter}s before retrying. Check leadbay_get_quota to see which resource window was hit.` : "Wait, then retry. Check leadbay_get_quota to see which resource window (daily/weekly/monthly) was hit.", endpoint, retryAfter);
@@ -340,9 +419,9 @@ var LeadbayClient = class {
     if (status === 403) {
       const msg = parsed?.message || parsed?.error || parsed?.error?.message || "";
       if (typeof msg === "string" && (msg.includes("suspend") || msg.includes("billing"))) {
-        return this.makeError("BILLING_SUSPENDED", "Account billing is suspended", "Your Leadbay account billing is suspended. Update at https://app.leadbay.ai", endpoint);
+        return this.makeError("BILLING_SUSPENDED", "Account billing is suspended", "Your Leadbay account billing is suspended. Contact Leadbay support.", endpoint);
       }
-      return this.makeError("FORBIDDEN", "Insufficient permissions", "Your token does not have access to this resource. Check account permissions at https://app.leadbay.ai", endpoint);
+      return this.makeError("FORBIDDEN", "Insufficient permissions", "Your token does not have access to this resource. Contact Leadbay support to verify account permissions.", endpoint);
     }
     if (status === 404) {
       return this.makeError("NOT_FOUND", parsed?.message || parsed?.error?.message || "Resource not found", "Verify the ID is correct", endpoint);
@@ -587,6 +666,11 @@ var getLeadProfile = {
   },
   execute: async (client, params) => {
     const lensId = params.lensId ?? await client.resolveDefaultLens();
+    void client.request("POST", "/interactions", [
+      { type: "LEAD_SEEN", leadId: params.leadId, lensId: String(lensId) },
+      { type: "LEAD_CLICKED", leadId: params.leadId, lensId: String(lensId) }
+    ]).catch(() => {
+    });
     const [leadResult, qualResult, contactsResult, paidContactsResult, webFetchResult] = await Promise.allSettled([
       client.request("GET", `/lenses/${lensId}/leads/${params.leadId}`),
       client.request("GET", `/leads/${params.leadId}/ai_agent_responses`),
@@ -754,7 +838,7 @@ var getTasteProfile = {
         question: q.question
       })),
       ...isEmpty ? {
-        hint: "No taste profile configured yet. Set it up at app.leadbay.ai for better lead matching."
+        hint: "No taste profile configured yet. Use leadbay_refine_prompt or contact Leadbay support to set one up for better lead matching."
       } : {}
     };
   }
@@ -827,7 +911,7 @@ var enrichContacts = {
       const me = await client.request("GET", "/users/me");
       creditsRemaining = me.organization.billing?.ai_credits ?? null;
       if (creditsRemaining !== null && creditsRemaining <= 0) {
-        throw client.makeError("QUOTA_EXCEEDED", "No enrichment credits remaining", "Purchase more credits at app.leadbay.ai");
+        throw client.makeError("QUOTA_EXCEEDED", "No enrichment credits remaining", "Contact Leadbay support to extend your credit quota");
       }
     } catch (e) {
       if (e?.code === "QUOTA_EXCEEDED")
@@ -1322,12 +1406,12 @@ var setUserPrompt = {
         would_call: {
           method: "POST",
           path: `/organizations/${orgId}/user_prompt`,
-          body: { prompt: params.prompt }
+          body: { user_prompt: params.prompt }
         }
       };
     }
     await client.requestVoid("POST", `/organizations/${orgId}/user_prompt`, {
-      prompt: params.prompt
+      user_prompt: params.prompt
     });
     client.invalidateMe();
     return { set: true };
@@ -1664,11 +1748,11 @@ function summarise(responses) {
   if (excerpt && excerpt.length > 200) {
     excerpt = excerpt.slice(0, 197) + "...";
   }
-  return { answered, total, avg_score_0_to_10: avg, best_response_excerpt: excerpt };
+  return { answered, total, avg_qualification_boost: avg, best_response_excerpt: excerpt };
 }
 var pullLeads = {
   name: "leadbay_pull_leads",
-  description: "Pull up new leads from the user's last-active lens (the canonical 'show me prospects to work on' tool). Each returned lead carries a one-line qualification_summary built from leadbay_ai_agent_responses, plus the rich tags / scores / recommended_contact_title / engagement counters / in-flight flags from the lead summary. When to use: as the agent's default opening move when the user wants to see leads. When NOT to use: when the user has named a specific lens \u2014 pass lensId to override the auto-resolution. Replaces the older leadbay_find_prospects (which is removed in v0.2.0).",
+  description: "Pull up new leads from the user's last-active lens \u2014 the canonical 'show me today's prospects' tool. Leadbay works like an inbox: each time the user logs back in, a fresh batch is delivered, paced by how many leads they've actually acted on recently. Pulling more won't produce more; user outreach/skips/saves does. Each returned lead carries a one-line qualification_summary built from leadbay_ai_agent_responses, plus the rich tags / scores / recommended_contact_title / engagement counters / in-flight flags from the lead summary. Roughly the top 10 of the batch come pre-qualified (populated qualification_summary + ai_agent_lead_score); leads below the top ~10 carry only the basic firmographic `score` \u2014 not worse, just resource-saved by the system. Call leadbay_bulk_qualify_leads to deepen any of them on demand. When to use: as the agent's default opening move when the user wants to see leads, or as a daily check-in for what's new today. When NOT to use: when the user has named a specific lens \u2014 pass lensId to override the auto-resolution. Replaces the older leadbay_find_prospects (which is removed in v0.2.0).",
   inputSchema: {
     type: "object",
     properties: {
@@ -1701,7 +1785,7 @@ var pullLeads = {
           summary: {
             answered: 0,
             total: 0,
-            avg_score_0_to_10: null,
+            avg_qualification_boost: null,
             best_response_excerpt: null
           }
         };
@@ -1783,7 +1867,7 @@ function reshapeWebFetchContent(content) {
 }
 var researchLead = {
   name: "leadbay_research_lead",
-  description: "Tell me everything decision-relevant about a single lead. Bundles the lens-scoped lead profile, the AI qualification answers (the agent's knowledge-base food), the structured web-research signals (with hot flags + sources), the enriched contacts, and the recent notes/epilogue/prospecting activity in one call. Order is deliberate: qualification first, then signals, then firmographics, then contacts, then engagement. When to use: when picking up a single lead from leadbay_pull_leads to decide whether to act on it. When NOT to use: across many leads at once \u2014 that's leadbay_pull_leads' job. (This composite supersedes the lower-level leadbay_get_lead_profile in agent flow; the granular tool stays available for fine-grained access.)",
+  description: "Tell me everything decision-relevant about a single lead. Bundles the lens-scoped lead profile, the AI qualification answers (the agent's knowledge-base food), the structured web-research signals (with hot flags + sources), the enriched contacts, and the recent notes/epilogue/prospecting activity in one call. Order is deliberate: qualification first, then signals, then firmographics, then contacts, then engagement. Scoring has two layers: the basic `score` (firmographic, always present, already decent) and the AI qualification layer (`ai_agent_lead_score` + per-question answers + web_fetch signals). The AI layer is pre-populated for roughly the top 10 of each daily batch, and on-demand (via leadbay_bulk_qualify_leads) for anything below that. Combine both layers when judging a lead. When to use: when picking up a single lead from leadbay_pull_leads to decide whether to act on it. When NOT to use: across many leads at once \u2014 that's leadbay_pull_leads' job. (This composite supersedes the lower-level leadbay_get_lead_profile in agent flow; the granular tool stays available for fine-grained access.)",
   inputSchema: {
     type: "object",
     properties: {
@@ -1802,6 +1886,11 @@ var researchLead = {
   execute: async (client, params, ctx) => {
     const lensId = params.lensId ?? await client.resolveDefaultLens();
     const leadId = params.leadId;
+    void client.request("POST", "/interactions", [
+      { type: "LEAD_SEEN", leadId, lensId: String(lensId) },
+      { type: "LEAD_CLICKED", leadId, lensId: String(lensId) }
+    ]).catch(() => {
+    });
     const [profileR, qualR, contactsR, webFetchR] = await Promise.allSettled([
       client.request("GET", `/lenses/${lensId}/leads/${leadId}`),
       client.request("GET", `/leads/${leadId}/ai_agent_responses`),
@@ -1997,7 +2086,7 @@ var recallOrderedTitles = {
 // ../core/dist/composite/account-status.js
 var accountStatus = {
   name: "leadbay_account_status",
-  description: "Show the user's account state \u2014 admin rights, language, last-active lens, current quota usage across daily/weekly/monthly windows for llm_completion / ai_rescore / web_fetch resources, and whether the org's intelligence is mid-regeneration. When to use: at the start of a session to know what the agent can/can't do, or after a 429 to explain to the user which resource window was exhausted and when it resets. When NOT to use: as a pre-flight gate before bulk ops \u2014 operations themselves return 429; this tool is for context, not gating.",
+  description: "Show the user's account state \u2014 admin rights, language, last-active lens, current quota usage across daily/weekly/monthly windows for llm_completion / ai_rescore / web_fetch resources, and whether the org's intelligence is mid-regeneration. Quota windows also hint at the user's consumption pace: heavy recent activity (ai_rescore / web_fetch near their window limits) is a signal that Leadbay will deliver a larger fresh batch next time the user logs back in, since batch size is paced by real consumption. When to use: at the start of a session to know what the agent can/can't do, or after a 429 to explain to the user which resource window was exhausted and when it resets. When NOT to use: as a pre-flight gate before bulk ops \u2014 operations themselves return 429; this tool is for context, not gating.",
   inputSchema: { type: "object", properties: {} },
   execute: async (client, _params, ctx) => {
     const me = await client.resolveMe();
@@ -2042,7 +2131,7 @@ var DEFAULT_PER_LEAD_BUDGET_MS = 9e4;
 var DEFAULT_TOTAL_BUDGET_MS = 5 * 6e4;
 var bulkQualifyLeads = {
   name: "leadbay_bulk_qualify_leads",
-  description: "Pick the next N unqualified leads in the active lens and qualify them (run AI rescore + web fetch), polling until the answers are populated or a budget is exhausted. Already-qualified leads (those with a non-null ai_agent_lead_score) are silently no-ops on the backend, so this composite paginates past them to find fresh candidates. On 429 mid-fanout, stops launching but keeps polling already-launched leads. When to use: when the user wants more qualified leads than what's currently shown. When NOT to use: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced).",
+  description: "Pick the next N unqualified leads in the active lens and qualify them (run AI rescore + web fetch), polling until the answers are populated or a budget is exhausted. Already-qualified leads (those with a non-null ai_agent_lead_score) are silently no-ops on the backend, so this composite paginates past them to find fresh candidates. On 429 mid-fanout, stops launching but keeps polling already-launched leads. Context: Leadbay auto-qualifies roughly the top 10 of each daily batch. Leads below the top ~10 are NOT worse \u2014 the system is saving resources. This tool is how the agent spends more resources to go deeper on promising-looking leads the user hasn't had time to surface yet. When to use: when the user wants more qualified leads than what's currently shown, or when a lead looks promising in leadbay_pull_leads but has an empty qualification_summary. When NOT to use: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced).",
   inputSchema: {
     type: "object",
     properties: {
@@ -2169,7 +2258,7 @@ var bulkQualifyLeads = {
         qualification_summary: responses.length > 0 ? {
           answered: responses.filter((r) => r.score != null).length,
           total: responses.length,
-          avg_score_0_to_10: avg
+          avg_qualification_boost: avg
         } : null,
         signals_count: lastWf?.content ? Object.values(lastWf.content).reduce((acc, arr) => acc + (Array.isArray(arr) ? arr.length : 0), 0) : null,
         _stillRunning: stillRunning
@@ -2190,11 +2279,515 @@ var bulkQualifyLeads = {
   }
 };
 
+// ../core/dist/composite/import-leads.js
+import { randomUUID } from "crypto";
+var CHUNK_SIZE = 100;
+var POLL_INTERVAL_MS = 2e3;
+var DEFAULT_PER_PHASE_BUDGET_MS = 6e4;
+var DEFAULT_TOTAL_BUDGET_MS2 = 3e5;
+var STABILIZATION_POLLS = 2;
+var PUBLIC_MAILBOX_DOMAINS = /* @__PURE__ */ new Set([
+  "gmail.com",
+  "googlemail.com",
+  "yahoo.com",
+  "ymail.com",
+  "outlook.com",
+  "hotmail.com",
+  "live.com",
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  "aol.com",
+  "proton.me",
+  "protonmail.com",
+  "tutanota.com",
+  "gmx.com",
+  "gmx.net",
+  "gmx.de",
+  "mail.com",
+  "yandex.com",
+  "yandex.ru",
+  "qq.com",
+  "163.com",
+  "126.com"
+]);
+function normalizeDomain(input) {
+  if (!input || typeof input !== "string")
+    return null;
+  let v = input.trim().toLowerCase();
+  if (!v)
+    return null;
+  v = v.replace(/^https?:\/\//, "");
+  v = v.replace(/^www\./, "");
+  v = v.split("/")[0].split("?")[0].split("#")[0];
+  v = v.replace(/\.+$/, "");
+  if (!v)
+    return null;
+  if (/\s/.test(v))
+    return null;
+  if (!v.includes("."))
+    return null;
+  if (v.startsWith(".") || v.endsWith("."))
+    return null;
+  const parts = v.split(".");
+  if (parts.length < 2)
+    return null;
+  if (parts.some((p) => p.length === 0))
+    return null;
+  const tld = parts[parts.length - 1];
+  if (!/^[a-z]{2,}$/.test(tld) && !tld.startsWith("xn--"))
+    return null;
+  if (!/^[a-z0-9-]+$/.test(parts[parts.length - 2]))
+    return null;
+  return v;
+}
+function escapeCsvCell(raw) {
+  if (raw == null)
+    return "";
+  let s = String(raw);
+  const trimmed = s.replace(/^[\s\r\n\t]+/, "");
+  if (trimmed.length > 0) {
+    const first = trimmed[0];
+    if (first === "=" || first === "+" || first === "-" || first === "@") {
+      s = "'" + s;
+    }
+  }
+  if (/[",\n\r]/.test(s)) {
+    s = '"' + s.replace(/"/g, '""') + '"';
+  }
+  return s;
+}
+function synthesizeCsv(rows) {
+  const lines = ["MCP_ROW_ID,LEAD_NAME,LEAD_WEBSITE"];
+  for (const r of rows) {
+    lines.push([escapeCsvCell(r.rowId), escapeCsvCell(r.name), escapeCsvCell(r.website)].join(","));
+  }
+  return lines.join("\n") + "\n";
+}
+function chunkAt100(items) {
+  if (items.length === 0)
+    return [];
+  const chunks = [];
+  for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+    chunks.push(items.slice(i, i + CHUNK_SIZE));
+  }
+  return chunks;
+}
+function checkAborted(signal) {
+  if (signal?.aborted) {
+    throw Object.assign(new Error("aborted"), { name: "AbortError" });
+  }
+}
+async function sleepWithAbort(ms, signal) {
+  if (!signal) {
+    await new Promise((r) => setTimeout(r, ms));
+    return;
+  }
+  if (signal.aborted) {
+    checkAborted(signal);
+  }
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      signal.removeEventListener("abort", onAbort);
+      reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function readCell(record, key) {
+  const want = key.toLowerCase();
+  const arr = record.records;
+  if (Array.isArray(arr)) {
+    for (const c of arr) {
+      const k = (c?.column_name ?? c?.key ?? c?.field ?? "").toString().toLowerCase();
+      if (k === want) {
+        const v = c?.value ?? null;
+        return v != null ? String(v) : null;
+      }
+    }
+  }
+  const cells = record.cells;
+  if (cells && typeof cells === "object" && !Array.isArray(cells)) {
+    for (const [k, v] of Object.entries(cells)) {
+      if (k.toLowerCase() === want) {
+        return v != null ? String(v) : null;
+      }
+    }
+  }
+  if (Array.isArray(cells)) {
+    for (const c of cells) {
+      const k = (c?.key ?? c?.field ?? c?.column_name ?? "").toString().toLowerCase();
+      if (k === want) {
+        const v = c?.value ?? null;
+        return v != null ? String(v) : null;
+      }
+    }
+  }
+  return null;
+}
+function buildInputLookup(inputs) {
+  const validInputs = [];
+  const malformed = [];
+  const byDomain = /* @__PURE__ */ new Map();
+  const byRowId = /* @__PURE__ */ new Map();
+  inputs.forEach((inp, i) => {
+    void i;
+    const norm = normalizeDomain(inp.domain ?? "");
+    if (!norm) {
+      malformed.push(inp.domain ?? "");
+      return;
+    }
+    if (byDomain.has(norm))
+      return;
+    const rowId = randomUUID();
+    const idx = validInputs.length;
+    validInputs.push({ index: idx, rowId, domain: norm, name: inp.name?.trim() || norm });
+    byDomain.set(norm, idx);
+    byRowId.set(rowId, idx);
+  });
+  return { validInputs, malformed, byDomain, byRowId };
+}
+async function pollUntil(fn, done, budgetMs, signal, ctx, label) {
+  const deadline = Date.now() + budgetMs;
+  let last;
+  while (true) {
+    checkAborted(signal);
+    last = await fn();
+    if (done(last))
+      return last;
+    if (Date.now() >= deadline) {
+      ctx?.logger?.warn?.(`import-leads: ${label} budget exhausted (${budgetMs}ms)`);
+      return last;
+    }
+    await sleepWithAbort(POLL_INTERVAL_MS, signal);
+  }
+}
+async function pollPreprocess(client, importId, budgetMs, ctx, signal) {
+  const result = await pollUntil(() => client.request("GET", `/imports/${importId}`), (r) => Boolean(r.pre_processing?.finished), budgetMs, signal, ctx, "preprocess");
+  if (!result.pre_processing?.finished) {
+    throw client.makeError("IMPORT_BUDGET_EXHAUSTED", `Preprocess phase did not finish within ${budgetMs}ms`, `Increase per_phase_budget_ms (current: ${budgetMs}) or split the batch. importId=${importId}.`, `GET /imports/${importId}`);
+  }
+  if (result.pre_processing.error) {
+    throw client.makeError("IMPORT_PREPROCESS_FAILED", `Preprocess failed: ${result.pre_processing.error}`, `Check the input domains. importId=${importId} for backend debugging.`, `GET /imports/${importId}`);
+  }
+  return result;
+}
+async function pollProcess(client, importId, budgetMs, ctx, signal) {
+  const result = await pollUntil(() => client.request("GET", `/imports/${importId}`), (r) => Boolean(r.processing?.finished), budgetMs, signal, ctx, "process");
+  if (!result.processing?.finished) {
+    throw client.makeError("IMPORT_BUDGET_EXHAUSTED", `Process phase did not finish within ${budgetMs}ms`, `Increase per_phase_budget_ms (current: ${budgetMs}) or split the batch. importId=${importId}.`, `GET /imports/${importId}`);
+  }
+  if (result.processing.error != null) {
+    throw client.makeError("IMPORT_PROCESSING_FAILED", `Backend processing failed: ${result.processing.error}`, `importId=${importId}.`, `GET /imports/${importId}`);
+  }
+  return result;
+}
+async function pollRecordsToTerminal(client, importId, budgetMs, expectedRowCount, ctx, signal) {
+  const deadline = Date.now() + budgetMs;
+  const maxPagesPerPoll = Math.max(2, Math.ceil(expectedRowCount / 100) * 2 + 4);
+  let stableCounts = 0;
+  let lastSnapshot = null;
+  while (true) {
+    checkAborted(signal);
+    let total = 0;
+    let transient = 0;
+    let pagesFetched = 0;
+    let exhaustedPagination = false;
+    const records = [];
+    for (let page = 0; page < maxPagesPerPoll; page++) {
+      checkAborted(signal);
+      const qs = `count=100&page=${page}&automatic_match=true&manual_match=true&no_match=true&matching=true&importing=true&imported=true`;
+      const res = await client.request("GET", `/imports/${importId}/records?${qs}`);
+      pagesFetched++;
+      records.push(...res.items);
+      total = res.pagination.total ?? records.length;
+      for (const r of res.items) {
+        const status = (r.status ?? "").toString().toUpperCase();
+        const matchType = (r.match_type ?? r.matchType ?? "").toString().toUpperCase();
+        const isTerminal = matchType === "NO_MATCH" || status === "IMPORTED";
+        if (!isTerminal)
+          transient++;
+      }
+      const totalPages = res.pagination.pages ?? 0;
+      if (page + 1 >= totalPages) {
+        exhaustedPagination = true;
+        break;
+      }
+    }
+    if (!exhaustedPagination) {
+      throw client.makeError("IMPORT_PAGINATION_RUNAWAY", `Records pagination exceeded ${maxPagesPerPoll} pages`, `importId=${importId}. Please file a bug at https://github.com/leadbay/leadclaw/issues.`, `GET /imports/${importId}/records`);
+    }
+    const snapshot = { total, transient };
+    const settled = transient === 0;
+    const stableVsLast = lastSnapshot != null && lastSnapshot.total === snapshot.total && lastSnapshot.transient === snapshot.transient;
+    if (settled && stableVsLast) {
+      stableCounts++;
+    } else if (settled) {
+      stableCounts = 1;
+    } else {
+      stableCounts = 0;
+    }
+    lastSnapshot = snapshot;
+    if (settled && stableCounts >= STABILIZATION_POLLS) {
+      return records;
+    }
+    if (Date.now() >= deadline) {
+      ctx?.logger?.warn?.(`import-leads: records did not stabilize (transient=${transient}, total=${total}); returning best-effort`);
+      throw client.makeError("IMPORT_NOT_TERMINAL", `Backend hasn't fully settled records within ${budgetMs}ms`, `Retry leadbay_import_leads with the same domains in 30s, or split the batch. importId=${importId}.`, `GET /imports/${importId}/records`);
+    }
+    await sleepWithAbort(POLL_INTERVAL_MS, signal);
+  }
+}
+async function runOneChunk(client, chunk, chunkIdx, totalChunks, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onImportId) {
+  const csv = synthesizeCsv(chunk.map((c) => ({ rowId: c.rowId, name: c.name, website: c.domain })));
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const fileName = `mcp-import-${ts}-${chunkIdx}.csv`;
+  ctx?.logger?.info?.(`import-leads: uploading chunk ${chunkIdx + 1}/${totalChunks} (${chunk.length} rows, ${csv.length}B)`);
+  const upload = await client.requestRawBinary("POST", `/imports?file_name=${encodeURIComponent(fileName)}`, "text/csv", csv);
+  const importId = upload.id;
+  onImportId(importId);
+  const phaseBudget = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
+  await pollPreprocess(client, importId, phaseBudget, ctx, signal);
+  ctx?.logger?.info?.(`import-leads: preprocess done for importId=${importId}`);
+  if (dryRun) {
+    return { importId, records: [] };
+  }
+  const mappings = {
+    fields: { LEAD_NAME: "LEAD_NAME", LEAD_WEBSITE: "LEAD_WEBSITE" },
+    statuses: {},
+    default_status: null
+  };
+  await client.requestVoid("POST", `/imports/${importId}/update_mappings`, mappings);
+  ctx?.logger?.info?.(`import-leads: mappings committed for importId=${importId}`);
+  const phaseBudget2 = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
+  await pollProcess(client, importId, phaseBudget2, ctx, signal);
+  ctx?.logger?.info?.(`import-leads: process done for importId=${importId}`);
+  const phaseBudget3 = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
+  const records = await pollRecordsToTerminal(client, importId, phaseBudget3, chunk.length, ctx, signal);
+  ctx?.logger?.info?.(`import-leads: ${records.length} records terminal for importId=${importId}`);
+  return { importId, records };
+}
+function reconcileOneChunk(chunk, byRowIdGlobal, byDomainGlobal, validInputsGlobal, matched, notImported) {
+  const seenInputIndex = /* @__PURE__ */ new Set();
+  const sortedRecords = [...chunk.records].sort((a, b) => {
+    const aHasLead = a.lead?.id ? 0 : 1;
+    const bHasLead = b.lead?.id ? 0 : 1;
+    return aHasLead - bHasLead;
+  });
+  for (const rec of sortedRecords) {
+    let inputIdx;
+    const rowIdCell = readCell(rec, "MCP_ROW_ID");
+    if (rowIdCell && byRowIdGlobal.has(rowIdCell)) {
+      inputIdx = byRowIdGlobal.get(rowIdCell);
+    }
+    if (inputIdx === void 0) {
+      const websiteCell = readCell(rec, "LEAD_WEBSITE");
+      if (websiteCell) {
+        const norm = normalizeDomain(websiteCell);
+        if (norm && byDomainGlobal.has(norm)) {
+          inputIdx = byDomainGlobal.get(norm);
+        }
+      }
+    }
+    if (inputIdx === void 0 && rec.lead?.website) {
+      const norm = normalizeDomain(rec.lead.website);
+      if (norm && byDomainGlobal.has(norm)) {
+        inputIdx = byDomainGlobal.get(norm);
+      }
+    }
+    if (inputIdx === void 0)
+      continue;
+    if (seenInputIndex.has(inputIdx)) {
+      if (!matched.has(inputIdx) && !notImported.has(inputIdx)) {
+        const inp2 = validInputsGlobal[inputIdx];
+        notImported.set(inputIdx, { domain: inp2.domain, reason: "ambiguous" });
+      }
+      continue;
+    }
+    seenInputIndex.add(inputIdx);
+    const inp = validInputsGlobal[inputIdx];
+    const matchType = (rec.match_type ?? rec.matchType ?? "").toString();
+    if (rec.lead?.id) {
+      matched.set(inputIdx, {
+        domain: inp.domain,
+        leadId: rec.lead.id,
+        name: rec.lead.name ?? null
+      });
+    } else if (matchType === "NO_MATCH") {
+      const reason = PUBLIC_MAILBOX_DOMAINS.has(inp.domain) ? "no_match" : "uncrawled";
+      notImported.set(inputIdx, { domain: inp.domain, reason });
+    } else {
+      notImported.set(inputIdx, { domain: inp.domain, reason: "internal_error" });
+    }
+  }
+}
+var importLeads = {
+  name: "leadbay_import_leads",
+  description: "Import a list of company domains and get back stable Leadbay leadIds for downstream chaining into leadbay_bulk_qualify_leads / leadbay_research_lead.\n\n\u26A0\uFE0F MUTATES USER STATE. This tool wraps Leadbay's CRM-import wizard. Each call:\n  - creates a row in the user's CRM-imports list (visible in the web UI)\n  - touches onboarding state (startFileless, onboarding step \u2192 PROCESSING)\nSuitable for occasional automation. NOT suitable for high-cadence (>5 calls/day) \u2014 wait for the backend programmatic endpoint (issue: leadbay/backend prolonged-import-with-crawl).\n\nReturns: leads = leadIds for domains Leadbay already knows about (via crawler). not_imported = domains Leadbay doesn't know yet, with a reason. The tool does NOT create new leads for unknown domains; the caller decides what to do.\n\nWhen to use: you have a list of domains from another system (CRM, analytics, email correspondents) and need to map them to Leadbay leadIds.\nWhen NOT to use: for prospect discovery (use leadbay_pull_leads); for one specific company's profile (use leadbay_research_company); when you can't tolerate the side effects above.\n\nRequires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role on the Leadbay account; active billing.",
+  write: true,
+  version: "0.1.0",
+  inputSchema: {
+    type: "object",
+    properties: {
+      domains: {
+        type: "array",
+        description: "List of company domains to map to Leadbay leadIds.",
+        items: {
+          type: "object",
+          properties: {
+            domain: {
+              type: "string",
+              description: "Company domain (e.g. 'apple.com'). Protocol/path are stripped."
+            },
+            name: {
+              type: "string",
+              description: "Optional display name override; defaults to the domain."
+            }
+          },
+          required: ["domain"]
+        }
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, run preprocess only \u2014 do NOT commit lead-CRM linking. Note: an import row still appears in the user's CRM-imports list as 'incomplete'. Use to verify domain format / wizard reachability without polluting the CRM."
+      },
+      per_phase_budget_ms: {
+        type: "number",
+        description: `Single poll-loop cap (default ${DEFAULT_PER_PHASE_BUDGET_MS}ms).`
+      },
+      total_budget_ms: {
+        type: "number",
+        description: `Overall cap across all phases (default ${DEFAULT_TOTAL_BUDGET_MS2}ms).`
+      }
+    },
+    required: ["domains"]
+  },
+  execute: async (client, params, ctx) => {
+    const signal = ctx?.signal;
+    const dryRun = Boolean(params.dry_run);
+    const perPhaseBudget = params.per_phase_budget_ms ?? DEFAULT_PER_PHASE_BUDGET_MS;
+    const totalBudget = params.total_budget_ms ?? DEFAULT_TOTAL_BUDGET_MS2;
+    const totalDeadline = Date.now() + totalBudget;
+    if (!Array.isArray(params.domains) || params.domains.length === 0) {
+      throw client.makeError("IMPORT_EMPTY_INPUT", "domains[] must contain at least one entry", "Pass at least one domain in domains[].", "POST /imports");
+    }
+    const me = await client.resolveMe();
+    if (!me.admin) {
+      throw client.makeError("IMPORT_ADMIN_REQUIRED", "This tool requires admin role on the Leadbay account", "Ask the account owner to grant import permission, or use a token from an admin user.", "POST /imports");
+    }
+    const lookup = buildInputLookup(params.domains);
+    if (lookup.validInputs.length === 0) {
+      const not_imported2 = lookup.malformed.map((d) => ({
+        domain: d,
+        reason: "malformed"
+      }));
+      return {
+        leads: [],
+        not_imported: not_imported2,
+        importIds: [],
+        region: client.region,
+        dry_run: dryRun || void 0,
+        _meta: client.lastMeta ?? {
+          region: client.region,
+          endpoint: "POST /imports",
+          latency_ms: null,
+          retry_after: null
+        }
+      };
+    }
+    const chunks = chunkAt100(lookup.validInputs);
+    ctx?.logger?.info?.(`import-leads: ${lookup.validInputs.length} domains \u2192 ${chunks.length} chunk(s); dry_run=${dryRun}, totalBudgetMs=${totalBudget}`);
+    const importIds = [];
+    const matched = /* @__PURE__ */ new Map();
+    const notImported = /* @__PURE__ */ new Map();
+    let cancelled = false;
+    const recordImportId = (id) => {
+      if (!importIds.includes(id))
+        importIds.push(id);
+    };
+    try {
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const out = await runOneChunk(client, chunk, i, chunks.length, dryRun, perPhaseBudget, totalDeadline, ctx, signal, recordImportId);
+        if (!dryRun) {
+          reconcileOneChunk(out, lookup.byRowId, lookup.byDomain, lookup.validInputs, matched, notImported);
+        } else {
+          for (const c of chunk) {
+            notImported.set(c.index, { domain: c.domain, reason: "dry_run" });
+          }
+        }
+      }
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        cancelled = true;
+        ctx?.logger?.info?.(`import-leads: aborted via signal; importIds=${importIds.join(",")}`);
+      } else if (err?.error === true) {
+        if (err.code === "FORBIDDEN") {
+          throw client.makeError("IMPORT_ADMIN_REQUIRED", err.message || "Insufficient permissions for /imports", "This tool requires admin role on the Leadbay account. Ask the account owner.", err._meta?.endpoint);
+        }
+        if (err.code === "BILLING_SUSPENDED") {
+          throw client.makeError("IMPORT_BILLING_REQUIRED", err.message || "Active billing required for imports", "Upgrade at https://app.leadbay.ai/billing, then retry.", err._meta?.endpoint);
+        }
+        throw err;
+      } else {
+        throw err;
+      }
+    }
+    for (const m of lookup.malformed) {
+      notImported.set(-1 - notImported.size, { domain: m, reason: "malformed" });
+    }
+    const leads = [];
+    const not_imported = [];
+    if (dryRun) {
+      for (const inp of lookup.validInputs) {
+        not_imported.push({ domain: inp.domain, reason: "dry_run" });
+      }
+    } else {
+      for (const inp of lookup.validInputs) {
+        const m = matched.get(inp.index);
+        if (m) {
+          leads.push(m);
+          continue;
+        }
+        const ni = notImported.get(inp.index);
+        if (ni) {
+          not_imported.push(ni);
+          continue;
+        }
+        not_imported.push({ domain: inp.domain, reason: "internal_error" });
+      }
+    }
+    for (const [k, v] of notImported) {
+      if (k < 0)
+        not_imported.push(v);
+    }
+    return {
+      leads,
+      not_imported,
+      importIds,
+      region: client.region,
+      cancelled: cancelled || void 0,
+      dry_run: dryRun || void 0,
+      _meta: client.lastMeta ?? {
+        region: client.region,
+        endpoint: "POST /imports",
+        latency_ms: null,
+        retry_after: null
+      }
+    };
+  }
+};
+
 // ../core/dist/composite/enrich-titles.js
 var DEFAULT_CANDIDATE_COUNT = 25;
 var enrichTitles = {
   name: "leadbay_enrich_titles",
-  description: "Order contact enrichments by job title across many leads. Two modes: (A) NO titles param \u2014 returns the available titles + Leadbay's title_suggestions + auto_included_titles + a count of enrichable contacts, so the agent can ask the user which titles to enrich. (B) titles given \u2014 calls preview, then launches if there's anything enrichable. On 429 returns {status:'quota_exceeded'} cleanly. Selection lifecycle is wrapped in a try/finally so the user's selection is left clean even on error. When to use: as the agent's go-to enrichment entry point. When NOT to use: to enrich a single contact \u2014 that's leadbay_enrich_contacts (granular).",
+  description: "Order contact enrichments by job title across many leads. Contacts are NOT returned by default with a lead (Leadbay keeps enrichment out-of-band to control cost); the agent requests them on demand via this tool when it's ready to actually reach out. Two modes: (A) NO titles param \u2014 returns the available titles + Leadbay's title_suggestions + auto_included_titles + a count of enrichable contacts, so the agent can ask the user which titles to enrich. (B) titles given \u2014 calls preview, then launches if there's anything enrichable. On 429 returns {status:'quota_exceeded'} cleanly. Selection lifecycle is wrapped in a try/finally so the user's selection is left clean even on error. When to use: as the agent's go-to enrichment entry point, immediately before proposing outreach. When NOT to use: to enrich a single contact \u2014 that's leadbay_enrich_contacts (granular). Speculatively, before the user has committed to outreaching \u2014 enrichment spends credits.",
   inputSchema: {
     type: "object",
     properties: {
@@ -2235,9 +2828,11 @@ var enrichTitles = {
         hint: "Set email:true (most common) or phone:true"
       };
     }
+    const explicitLeadIds = params.leadIds && params.leadIds.length > 0;
+    const selectionSource = explicitLeadIds ? "explicit" : "wishlist";
+    const lensId = params.lensId ?? await client.resolveDefaultLens();
     let leadIds = params.leadIds;
     if (!leadIds || leadIds.length === 0) {
-      const lensId = params.lensId ?? await client.resolveDefaultLens();
       const cnt = params.candidateCount ?? DEFAULT_CANDIDATE_COUNT;
       const wish = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=${Math.min(cnt, 50)}&page=0`);
       leadIds = wish.items.map((l) => l.id);
@@ -2311,9 +2906,53 @@ var enrichTitles = {
             would_launch: { titles: params.titles, email, phone }
           };
         }
+        const tracker = ctx?.bulkTracker;
+        let bulkRecord;
+        let bulkReused = false;
+        let bulkSecondsSinceOriginal;
+        if (tracker) {
+          const res = await tracker.findOrCreatePending({
+            lead_ids: leadIds,
+            titles: params.titles,
+            email,
+            phone,
+            lens_id: lensId,
+            selection_source: selectionSource
+          });
+          bulkRecord = {
+            bulk_id: res.record.bulk_id,
+            launched_at: res.record.launched_at,
+            durability: res.record.durability
+          };
+          bulkReused = res.reused;
+          bulkSecondsSinceOriginal = res.seconds_since_original;
+          if (bulkReused && res.record.status !== "failed") {
+            return {
+              mode: "already_launched",
+              re_used: true,
+              bulk_id: res.record.bulk_id,
+              launched_at: res.record.launched_at,
+              durability: res.record.durability,
+              seconds_since_original_launch: bulkSecondsSinceOriginal ?? 0,
+              titles: params.titles,
+              email,
+              phone,
+              preview,
+              message: `No new enrichment was ordered; quota not spent. An identical bulk was launched ${bulkSecondsSinceOriginal ?? 0}s ago. Poll leadbay_bulk_enrich_status with this bulk_id for results.`,
+              next_action: "Call leadbay_bulk_enrich_status({bulk_id}) to check progress; include_contacts=true for the final read."
+            };
+          }
+        }
         try {
           await client.requestVoid("POST", "/leads/selection/enrichment/launch", { titles: params.titles, email, phone });
         } catch (err) {
+          if (bulkRecord && tracker) {
+            try {
+              await tracker.markFailed(bulkRecord.bulk_id);
+            } catch (e) {
+              ctx?.logger?.warn?.(`enrich_titles: tracker.markFailed failed: ${e?.message ?? e}`);
+            }
+          }
           if (err?.code === "QUOTA_EXCEEDED") {
             return {
               status: "quota_exceeded",
@@ -2324,6 +2963,26 @@ var enrichTitles = {
           }
           throw err;
         }
+        if (bulkRecord && tracker) {
+          try {
+            await tracker.markLaunched(bulkRecord.bulk_id);
+          } catch (e) {
+            ctx?.logger?.warn?.(`enrich_titles: tracker.markLaunched failed: ${e?.message ?? e}`);
+            return {
+              mode: "launched_tracker_pending",
+              launched: true,
+              preview,
+              bulk_id: bulkRecord.bulk_id,
+              launched_at: bulkRecord.launched_at,
+              durability: bulkRecord.durability,
+              titles: params.titles,
+              email,
+              phone,
+              message: "Enrichment job launched on the backend, but the local tracker record could not be flipped to 'launched'. The bulk_id is still valid \u2014 leadbay_bulk_enrich_status will return status:'pending' until the tracker heals.",
+              next_action: "Wait ~60s, then call leadbay_bulk_enrich_status({bulk_id}). If it persists, restart the MCP."
+            };
+          }
+        }
         return {
           mode: "launched",
           preview,
@@ -2331,8 +2990,11 @@ var enrichTitles = {
           titles: params.titles,
           email,
           phone,
-          message: "Enrichment job launched. The Leadbay backend does not return a bulk_id (probed 2026-04-20) \u2014 track results by polling individual leads via leadbay_get_contacts after ~60s; contact.enrichment.done flips to true.",
-          next_action: "Wait ~60s, then call leadbay_research_lead or leadbay_get_contacts on the leads you care about."
+          bulk_id: bulkRecord?.bulk_id,
+          launched_at: bulkRecord?.launched_at,
+          durability: bulkRecord?.durability,
+          message: bulkRecord ? "Enrichment job launched. Backend has no server-side bulk_id yet; MCP minted a client-side bulk_id (persisted to disk by default) so you can poll via leadbay_bulk_enrich_status." : "Enrichment job launched. No bulk_id tracker configured \u2014 poll leadbay_get_contacts per lead after ~60s; contact.enrichment.done flips to true.",
+          next_action: bulkRecord ? "Call leadbay_bulk_enrich_status({bulk_id}) after ~60s; pass include_contacts=true for the final read." : "Wait ~60s, then call leadbay_research_lead or leadbay_get_contacts on the leads you care about."
         };
       } finally {
         try {
@@ -2347,6 +3009,523 @@ var enrichTitles = {
   }
 };
 
+// ../core/dist/jobs/bulk-store.js
+import { mkdir as mkdirAsync, lstat, open as fsOpen, readFile, rename, stat, unlink } from "fs/promises";
+import { constants as fsConstants } from "fs";
+import { dirname, resolve as resolvePath } from "path";
+import { homedir, platform } from "os";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_IDEMPOTENCY_WINDOW_MS = 5 * 60 * 1e3;
+var TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var UUIDV4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isValidBulkId(v) {
+  return typeof v === "string" && UUIDV4_RE.test(v);
+}
+function computeIdempotencyKey(args) {
+  const parts = [
+    [...args.lead_ids].sort().join(","),
+    [...args.titles].sort().join(","),
+    args.email ? "e1" : "e0",
+    args.phone ? "p1" : "p0",
+    `l${args.lens_id}`
+  ];
+  return createHash("sha256").update(parts.join("|")).digest("hex");
+}
+function normalizeLaunchInputs(args) {
+  return {
+    lead_ids: [...new Set(args.lead_ids)].sort(),
+    titles: [...new Set(args.titles)].sort()
+  };
+}
+var AsyncMutex = class {
+  locked = false;
+  queue = [];
+  async lock() {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push(() => {
+        this.locked = true;
+        resolve();
+      });
+    });
+  }
+  unlock() {
+    this.locked = false;
+    const next = this.queue.shift();
+    if (next)
+      next();
+  }
+  async run(fn) {
+    await this.lock();
+    try {
+      return await fn();
+    } finally {
+      this.unlock();
+    }
+  }
+};
+var LocalBulkStore = class {
+  backend;
+  path;
+  logger;
+  allowUnsafePath;
+  now;
+  mutex = new AsyncMutex();
+  memory = [];
+  // Cached file resolution — computed lazily on first access.
+  initialized = false;
+  constructor(opts) {
+    this.backend = opts.backend;
+    this.logger = opts.logger;
+    this.allowUnsafePath = !!opts.allowUnsafePath;
+    this.now = opts.now ?? Date.now;
+    if (this.backend === "file") {
+      if (!opts.path) {
+        throw new Error("LocalBulkStore: path is required when backend=file");
+      }
+      this.path = resolvePath(opts.path);
+      this.validatePath(this.path);
+    }
+  }
+  get durability() {
+    return this.backend;
+  }
+  // Exposed for tests and ops tooling.
+  get resolvedPath() {
+    return this.path;
+  }
+  validatePath(p) {
+    if (this.allowUnsafePath)
+      return;
+    const home = resolvePath(homedir());
+    if (p !== home && !p.startsWith(home + "/") && !p.startsWith(home + "\\")) {
+      throw new Error(`LocalBulkStore: path ${p} is outside $HOME (${home}). Set LEADBAY_BULK_STORE_PATH_UNSAFE=1 to override.`);
+    }
+  }
+  async ensureInitialized() {
+    if (this.initialized || this.backend !== "file") {
+      this.initialized = true;
+      return;
+    }
+    const dir = dirname(this.path);
+    await mkdirAsync(dir, { recursive: true, mode: 448 });
+    try {
+      const st = await lstat(this.path);
+      if (st.isSymbolicLink()) {
+        throw new Error(`LocalBulkStore: refusing to use ${this.path} \u2014 path is a symlink. Set LEADBAY_BULK_STORE_PATH_UNSAFE=1 to override.`);
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT")
+        throw err;
+    }
+    this.initialized = true;
+  }
+  // ─── Storage layer (file or memory) ──────────────────────────────────────
+  async readAll() {
+    if (this.backend === "memory")
+      return [...this.memory];
+    await this.ensureInitialized();
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch (err) {
+      if (err?.code === "ENOENT")
+        return [];
+      throw err;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      this.logger?.warn?.(`bulk.record_dropped file_parse_failed ${err?.message ?? err}`);
+      return [];
+    }
+    if (!Array.isArray(parsed)) {
+      this.logger?.warn?.("bulk.record_dropped file_not_array");
+      return [];
+    }
+    const out = [];
+    for (const entry of parsed) {
+      try {
+        out.push(this.validateRecord(entry));
+      } catch (err) {
+        this.logger?.warn?.(`bulk.record_dropped invalid_record ${err?.message ?? err}`);
+      }
+    }
+    return out;
+  }
+  validateRecord(raw) {
+    if (!raw || typeof raw !== "object")
+      throw new Error("not an object");
+    const r = raw;
+    if (!isValidBulkId(r.bulk_id))
+      throw new Error("invalid bulk_id");
+    if (typeof r.launched_at !== "string")
+      throw new Error("missing launched_at");
+    if (!Array.isArray(r.lead_ids) || !r.lead_ids.every((x) => typeof x === "string"))
+      throw new Error("invalid lead_ids");
+    if (!Array.isArray(r.titles) || !r.titles.every((x) => typeof x === "string"))
+      throw new Error("invalid titles");
+    if (typeof r.email !== "boolean")
+      throw new Error("invalid email");
+    if (typeof r.phone !== "boolean")
+      throw new Error("invalid phone");
+    if (typeof r.lens_id !== "number")
+      throw new Error("invalid lens_id");
+    if (r.selection_source !== "explicit" && r.selection_source !== "wishlist")
+      throw new Error("invalid selection_source");
+    if (r.status !== "pending" && r.status !== "launched" && r.status !== "failed")
+      throw new Error("invalid status");
+    if (typeof r.idempotency_key !== "string")
+      throw new Error("invalid idempotency_key");
+    return {
+      bulk_id: r.bulk_id,
+      launched_at: r.launched_at,
+      lead_ids: r.lead_ids,
+      titles: r.titles,
+      email: r.email,
+      phone: r.phone,
+      lens_id: r.lens_id,
+      selection_source: r.selection_source,
+      status: r.status,
+      idempotency_key: r.idempotency_key,
+      durability: this.backend
+    };
+  }
+  async writeAll(records) {
+    if (this.backend === "memory") {
+      this.memory = records.map((r) => ({ ...r, durability: "memory" }));
+      return;
+    }
+    await this.ensureInitialized();
+    const payload = records.map((r) => ({ ...r, durability: "file" }));
+    const json = JSON.stringify(payload, null, 2);
+    const tmp = this.path + ".tmp";
+    let fh = await openTmpFileExclusive(tmp);
+    try {
+      await fh.writeFile(json, { encoding: "utf8" });
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
+    if (platform() === "win32") {
+      try {
+        await unlink(this.path);
+      } catch (err) {
+        if (err?.code !== "ENOENT")
+          throw err;
+      }
+    }
+    await rename(tmp, this.path);
+    try {
+      const dirFh = await fsOpen(dirname(this.path), "r");
+      try {
+        await dirFh.sync();
+      } finally {
+        await dirFh.close();
+      }
+    } catch {
+    }
+  }
+  // ─── TTL cleanup ─────────────────────────────────────────────────────────
+  prune(records) {
+    const cutoff = this.now() - TTL_MS;
+    const kept = [];
+    for (const r of records) {
+      const launched = Date.parse(r.launched_at);
+      if (Number.isFinite(launched) && launched >= cutoff) {
+        kept.push(r);
+      } else {
+        this.logger?.info?.(`bulk.ttl_dropped bulk_id=${r.bulk_id} launched_at=${r.launched_at}`);
+      }
+    }
+    return kept;
+  }
+  // ─── BulkTracker API ────────────────────────────────────────────────────
+  async findOrCreatePending(args) {
+    const { lead_ids, titles } = normalizeLaunchInputs(args);
+    const idempotency_key = computeIdempotencyKey({
+      lead_ids,
+      titles,
+      email: args.email,
+      phone: args.phone,
+      lens_id: args.lens_id
+    });
+    const window = args.idempotency_window_ms ?? DEFAULT_IDEMPOTENCY_WINDOW_MS;
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const nowMs = this.now();
+      const existing = all.find((r) => r.idempotency_key === idempotency_key && r.status !== "failed" && nowMs - Date.parse(r.launched_at) < window);
+      if (existing) {
+        this.logger?.info?.(`bulk.reused bulk_id=${existing.bulk_id} seconds_since_original=${Math.round((nowMs - Date.parse(existing.launched_at)) / 1e3)}`);
+        return {
+          record: existing,
+          reused: true,
+          seconds_since_original: Math.round((nowMs - Date.parse(existing.launched_at)) / 1e3)
+        };
+      }
+      const record = {
+        bulk_id: randomUUID2(),
+        launched_at: new Date(nowMs).toISOString(),
+        lead_ids,
+        titles,
+        email: args.email,
+        phone: args.phone,
+        lens_id: args.lens_id,
+        selection_source: args.selection_source,
+        status: "pending",
+        idempotency_key,
+        durability: this.backend
+      };
+      all.push(record);
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.registered bulk_id=${record.bulk_id} lens_id=${record.lens_id} lead_count=${record.lead_ids.length} titles_count=${record.titles.length} durability=${record.durability}`);
+      return { record, reused: false };
+    });
+  }
+  async markLaunched(bulk_id) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const idx = all.findIndex((r) => r.bulk_id === bulk_id);
+      if (idx < 0) {
+        throw new Error(`bulk_id not found: ${bulk_id}`);
+      }
+      all[idx] = { ...all[idx], status: "launched" };
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.launched bulk_id=${bulk_id}`);
+      return all[idx];
+    });
+  }
+  async markFailed(bulk_id) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const idx = all.findIndex((r) => r.bulk_id === bulk_id);
+      if (idx < 0) {
+        return;
+      }
+      all[idx] = { ...all[idx], status: "failed" };
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.launch_failed bulk_id=${bulk_id}`);
+    });
+  }
+  async get(bulk_id) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      return all.find((r) => r.bulk_id === bulk_id);
+    });
+  }
+  async list() {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      return [...all].sort((a, b) => Date.parse(b.launched_at) - Date.parse(a.launched_at));
+    });
+  }
+};
+async function openTmpFileExclusive(path) {
+  try {
+    return await fsOpen(path, fsConstants.O_CREAT | fsConstants.O_WRONLY | fsConstants.O_EXCL, 384);
+  } catch (err) {
+    if (err?.code === "EEXIST") {
+      await unlink(path).catch(() => {
+      });
+      return fsOpen(path, fsConstants.O_CREAT | fsConstants.O_WRONLY | fsConstants.O_EXCL, 384);
+    }
+    throw err;
+  }
+}
+var InMemoryBulkStore = class extends LocalBulkStore {
+  constructor(opts = {}) {
+    super({ backend: "memory", logger: opts.logger, now: opts.now });
+  }
+};
+async function createDefaultBulkStore(opts = {}) {
+  const env = opts.env ?? process.env;
+  const allowMemory = env.LEADBAY_BULK_STORE_ALLOW_MEMORY === "1";
+  const allowUnsafePath = env.LEADBAY_BULK_STORE_PATH_UNSAFE === "1";
+  const path = env.LEADBAY_BULK_STORE_PATH ?? resolvePath(homedir(), ".leadbay", "bulks.json");
+  try {
+    const store = new LocalBulkStore({
+      backend: "file",
+      path,
+      logger: opts.logger,
+      allowUnsafePath
+    });
+    await store.ensureInitialized();
+    await stat(dirname(path));
+    return store;
+  } catch (err) {
+    if (!allowMemory) {
+      const msg = `bulk store init failed at ${path}: ${err?.message ?? err}. Set LEADBAY_BULK_STORE_ALLOW_MEMORY=1 to fall back to in-memory (handles won't survive MCP restart), or set LEADBAY_BULK_STORE_PATH to a writable path.`;
+      opts.logger?.error?.(msg);
+      throw new Error(msg);
+    }
+    opts.logger?.warn?.(`bulk.fallback_memory path=${path} reason=${err?.message ?? err}`);
+    return new LocalBulkStore({ backend: "memory", logger: opts.logger });
+  }
+}
+
+// ../core/dist/composite/bulk-enrich-status.js
+var STATUS_FETCH_CONCURRENCY = 5;
+async function pMap(items, fn, concurrency) {
+  const out = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (true) {
+      const i = next++;
+      if (i >= items.length)
+        return;
+      out[i] = await fn(items[i], i);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+  return out;
+}
+var bulkEnrichStatus = {
+  name: "leadbay_bulk_enrich_status",
+  description: "Check status + per-lead contacts for a bulk enrichment you previously launched via leadbay_enrich_titles. Returns the bulk_id, progress per lead (done/total enrichable contacts), and overall progress. When include_contacts=true (opt-in), includes each contact's email/phone/job_title/enrichment.done. When to use: poll this after leadbay_enrich_titles returns a bulk_id. Default include_contacts=false for cheap status polls; set include_contacts=true once all_done flips for the final read. When NOT to use: as a substitute for leadbay_research_lead \u2014 that already includes enriched contacts for a single lead.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      bulk_id: {
+        type: "string",
+        description: "UUIDv4 returned by leadbay_enrich_titles at launch time. Required."
+      },
+      include_contacts: {
+        type: "boolean",
+        description: "If true, return the full contact list per lead (email, phone, enrichment.done). Default false \u2014 cheap status polls."
+      }
+    },
+    required: ["bulk_id"]
+  },
+  execute: async (client, params, ctx) => {
+    if (!isValidBulkId(params.bulk_id)) {
+      return {
+        error: true,
+        code: "BULK_INVALID_ID",
+        message: "bulk_id is not a valid UUIDv4",
+        hint: "Pass the bulk_id returned by leadbay_enrich_titles verbatim."
+      };
+    }
+    if (!ctx?.bulkTracker) {
+      return {
+        error: true,
+        code: "BULK_TRACKER_UNAVAILABLE",
+        message: "No BulkTracker configured on this MCP instance",
+        hint: "This composite requires a BulkTracker in ToolContext. Upgrade to @leadbay/mcp \u22650.3.0 or run with LEADBAY_BULK_STORE_ALLOW_MEMORY=1."
+      };
+    }
+    const includeContacts = params.include_contacts ?? false;
+    const startMs = Date.now();
+    let record;
+    try {
+      record = await ctx.bulkTracker.get(params.bulk_id);
+    } catch (err) {
+      return {
+        error: true,
+        code: "BULK_STORE_UNAVAILABLE",
+        message: `Bulk store read failed: ${err?.message ?? err}`,
+        hint: "Check the file at $LEADBAY_BULK_STORE_PATH (default ~/.leadbay/bulks.json). Set LEADBAY_BULK_STORE_ALLOW_MEMORY=1 to fall back to in-memory storage on startup (handles won't survive restart)."
+      };
+    }
+    if (!record) {
+      return {
+        error: true,
+        code: "BULK_NOT_FOUND",
+        message: "No bulk record for that bulk_id",
+        hint: "The record may have aged out (30-day TTL) or the MCP process was restarted without persistence. Launch a new enrichment via leadbay_enrich_titles."
+      };
+    }
+    if (record.status === "pending") {
+      return {
+        error: true,
+        code: "BULK_PENDING",
+        message: "Bulk is in 'pending' state \u2014 the launch is in flight or the MCP crashed between launch and ack.",
+        hint: "Retry leadbay_bulk_enrich_status in a few seconds. If it persists >60s, relaunch via leadbay_enrich_titles.",
+        bulk_id: record.bulk_id,
+        launched_at: record.launched_at
+      };
+    }
+    if (record.status === "failed") {
+      return {
+        error: true,
+        code: "BULK_LAUNCH_FAILED",
+        message: "The original /enrichment/launch POST failed; no backend enrichment was ordered.",
+        hint: "Call leadbay_enrich_titles again \u2014 the failed record won't block a fresh launch.",
+        bulk_id: record.bulk_id,
+        launched_at: record.launched_at
+      };
+    }
+    const results = await pMap(record.lead_ids, async (leadId) => {
+      try {
+        const out = await getContacts.execute(client, { leadId });
+        const contacts = Array.isArray(out?.contacts) ? out.contacts : [];
+        const enrichable = contacts.filter((c) => c && c.enrichment);
+        const done = enrichable.filter((c) => c.enrichment?.done === true).length;
+        const total = enrichable.length;
+        return {
+          kind: "ok",
+          lead_id: leadId,
+          done,
+          total,
+          contacts: includeContacts ? contacts : void 0
+        };
+      } catch (err) {
+        return {
+          kind: "fail",
+          lead_id: leadId,
+          code: err?.code ?? "UNKNOWN",
+          retry_after: err?._meta?.retry_after
+        };
+      }
+    }, STATUS_FETCH_CONCURRENCY);
+    const leads = [];
+    const partialFailures = [];
+    let totalDone = 0;
+    let totalAll = 0;
+    for (const r of results) {
+      if (r.kind === "fail") {
+        partialFailures.push({
+          lead_id: r.lead_id,
+          code: r.code,
+          ...r.retry_after !== void 0 ? { retry_after: r.retry_after } : {}
+        });
+        continue;
+      }
+      leads.push({
+        lead_id: r.lead_id,
+        ...r.contacts ? { contacts: r.contacts } : {},
+        enrichment_progress: { done: r.done, total: r.total }
+      });
+      totalDone += r.done;
+      totalAll += r.total;
+    }
+    const overallProgress = {
+      done: totalDone,
+      total: totalAll,
+      done_ratio: totalAll === 0 ? 0 : totalDone / totalAll
+    };
+    const allDone = totalAll > 0 && totalDone === totalAll && partialFailures.length === 0;
+    ctx?.logger?.info?.(`bulk.status_checked bulk_id=${record.bulk_id} done=${totalDone} total=${totalAll} wall_ms=${Date.now() - startMs}`);
+    return {
+      bulk_id: record.bulk_id,
+      launched_at: record.launched_at,
+      status: record.status,
+      durability: record.durability,
+      titles: record.titles,
+      email: record.email,
+      phone: record.phone,
+      lens_id: record.lens_id,
+      leads,
+      overall_progress: overallProgress,
+      all_done: allDone,
+      ...partialFailures.length > 0 ? { partial_failures: partialFailures } : {}
+    };
+  }
+};
+
 // ../core/dist/composite/adjust-audience.js
 function tokens(s) {
   return s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
@@ -2619,14 +3798,14 @@ var refinePrompt = {
         would_call: {
           method: "POST",
           path: `/organizations/${orgId}/user_prompt`,
-          body: { prompt: params.prompt }
+          body: { user_prompt: params.prompt }
         }
       };
     }
     const postedAt = Date.now();
     const STALE_GUARD_MS = 5e3;
     await client.requestVoid("POST", `/organizations/${orgId}/user_prompt`, {
-      prompt: params.prompt
+      user_prompt: params.prompt
     });
     client.invalidateMe();
     const attempts = params.clarification_poll_attempts ?? DEFAULT_POLL_ATTEMPTS;
@@ -2924,6 +4103,7 @@ var compositeReadTools = [
   researchLead,
   recallOrderedTitles,
   accountStatus,
+  bulkEnrichStatus,
   // Keep the existing composites available too.
   researchCompany,
   prepareOutreach
@@ -2934,7 +4114,8 @@ var compositeWriteTools = [
   adjustAudience,
   refinePrompt,
   answerClarification,
-  reportOutreach
+  reportOutreach,
+  importLeads
 ];
 var compositeTools = [
   ...compositeReadTools,
@@ -2945,6 +4126,7 @@ var tools = [...compositeTools, ...granularTools];
 export {
   REGIONS,
   createClient,
+  formatLoginError,
   resolveRegion,
   getMockJournal,
   clearMockJournal,
@@ -2995,7 +4177,13 @@ export {
   recallOrderedTitles,
   accountStatus,
   bulkQualifyLeads,
+  importLeads,
   enrichTitles,
+  isValidBulkId,
+  LocalBulkStore,
+  InMemoryBulkStore,
+  createDefaultBulkStore,
+  bulkEnrichStatus,
   adjustAudience,
   refinePrompt,
   answerClarification,