@leadbay/mcp 0.4.0 → 0.5.0

package/dist/{chunk-O2UOXRZO.js → chunk-MCTWP5F2.js}

@@ -1175,6 +1175,1294 @@ var getEnrichmentJobTitles = {
   }
 };
 
+// ../core/dist/composite/_qualify-helpers.js
+import { createHash } from "crypto";
+var POLL_INTERVAL_MS = 5e3;
+function buildQuestionOrder(questions) {
+  const out = /* @__PURE__ */ new Map();
+  questions.forEach((q, i) => {
+    if (q.question && !out.has(q.question))
+      out.set(q.question, i);
+  });
+  return out;
+}
+function sortQualifications(quals, order) {
+  if (!order || order.size === 0) {
+    return [...quals].sort((a, b) => a.question.localeCompare(b.question));
+  }
+  return [...quals].sort((a, b) => {
+    const ai = order.has(a.question) ? order.get(a.question) : Number.MAX_SAFE_INTEGER;
+    const bi = order.has(b.question) ? order.get(b.question) : Number.MAX_SAFE_INTEGER;
+    if (ai !== bi)
+      return ai - bi;
+    return a.question.localeCompare(b.question);
+  });
+}
+function summarizeQualifications(quals) {
+  if (quals.length === 0)
+    return void 0;
+  const scored = quals.filter((q) => q.score != null);
+  if (scored.length === 0)
+    return void 0;
+  const top = [...scored].sort((a, b) => Math.abs(b.score) - Math.abs(a.score)).slice(0, 2);
+  const labelOf = (s) => s >= 20 ? "strong positive" : s >= 10 ? "positive" : s <= -10 ? "negative" : "neutral";
+  const headlines = top.map((q) => `${labelOf(q.score)} on '${q.question}'`).join(", ");
+  return `answered ${scored.length}/${quals.length} \u2014 ${headlines}`;
+}
+async function fanOutWebFetchAndPoll(client, leadIds, opts) {
+  const { perLeadBudgetMs, totalDeadlineMs, signal, ctx, skipAlreadyQualifiedLensId, questionOrder } = opts;
+  const skipAlreadyQualifiedLaunch = opts.skipAlreadyQualifiedLaunch ?? true;
+  const launched = [];
+  const failed = [];
+  let quotaExceeded = false;
+  let cancelled = false;
+  let alreadyQualified = /* @__PURE__ */ new Set();
+  let notInLens = /* @__PURE__ */ new Set();
+  if (skipAlreadyQualifiedLensId !== void 0) {
+    try {
+      const pre = await prequalifiedLeads(client, leadIds, skipAlreadyQualifiedLensId, ctx);
+      alreadyQualified = pre.already_qualified;
+      notInLens = pre.not_in_lens;
+      if (alreadyQualified.size > 0) {
+        ctx?.logger?.info?.(`qualify: ${alreadyQualified.size}/${leadIds.length} leads already qualified \u2014 skipping web_fetch launch`);
+      }
+      if (notInLens.size > 0) {
+        ctx?.logger?.info?.(`qualify: ${notInLens.size}/${leadIds.length} leads NOT in active lens \u2014 surfacing in not_in_lens (won't be qualified server-side)`);
+      }
+    } catch (err) {
+      ctx?.logger?.warn?.(`qualify: prequalified preflight failed (${err?.code ?? err?.message ?? "unknown"}) \u2014 proceeding with full fan-out`);
+    }
+  }
+  for (let i = 0; i < leadIds.length; i++) {
+    if (signal?.aborted) {
+      cancelled = true;
+      break;
+    }
+    if (quotaExceeded)
+      break;
+    const leadId = leadIds[i];
+    if (notInLens.has(leadId)) {
+      continue;
+    }
+    if (skipAlreadyQualifiedLaunch && alreadyQualified.has(leadId)) {
+      launched.push(leadId);
+      continue;
+    }
+    try {
+      await client.requestVoid("POST", `/leads/${leadId}/web_fetch?force_fetch=false`);
+      launched.push(leadId);
+    } catch (err) {
+      if (err?.code === "QUOTA_EXCEEDED") {
+        quotaExceeded = true;
+        ctx?.logger?.warn?.(`qualify: 429 mid-fanout after launching ${launched.length}/${leadIds.length} \u2014 keeping polls in flight`);
+      } else if (err?.code === "NOT_FOUND") {
+        failed.push({ lead_id: leadId, error: "lead not found" });
+      } else if (err?.name === "AbortError") {
+        cancelled = true;
+        break;
+      } else {
+        failed.push({
+          lead_id: leadId,
+          error: err?.message ?? err?.code ?? "unknown"
+        });
+      }
+    }
+  }
+  const launchedSet = new Set(launched);
+  const not_launched = leadIds.filter((id) => !launchedSet.has(id) && !failed.some((f) => f.lead_id === id));
+  const skipped_already_qualified = launched.filter((id) => alreadyQualified.has(id));
+  const results = await Promise.all(launched.map(async (leadId) => {
+    const leadDeadline = Math.min(Date.now() + perLeadBudgetMs, totalDeadlineMs);
+    let lastQual = null;
+    let lastWf = null;
+    while (Date.now() < leadDeadline) {
+      if (signal?.aborted) {
+        cancelled = true;
+        break;
+      }
+      try {
+        const [wfR, qualR] = await Promise.allSettled([
+          client.request("GET", `/leads/${leadId}/web_fetch`),
+          client.request("GET", `/leads/${leadId}/ai_agent_responses`)
+        ]);
+        if (wfR.status === "fulfilled")
+          lastWf = wfR.value;
+        if (qualR.status === "fulfilled")
+          lastQual = qualR.value;
+        const done = lastWf !== null && lastWf.in_progress !== true && Array.isArray(lastQual) && lastQual.length > 0 && lastQual.every((r) => r.score != null);
+        if (done)
+          break;
+      } catch {
+      }
+      await sleepWithAbort(POLL_INTERVAL_MS, signal);
+      if (signal?.aborted) {
+        cancelled = true;
+        break;
+      }
+    }
+    const stillRunning = lastWf?.in_progress === true || !lastQual || lastQual.length === 0 || lastQual.some((r) => r.score == null);
+    const responses = lastQual ?? [];
+    const scores = responses.map((r) => r.score).filter((s) => s != null);
+    const avg = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10 : null;
+    const qualifications = sortQualifications(responses.map((r) => {
+      const out = {
+        question: r.question,
+        score: r.score,
+        response: r.response,
+        computed_at: r.computed_at
+      };
+      if (r.outdated_at !== void 0)
+        out.outdated_at = r.outdated_at;
+      return out;
+    }), questionOrder ?? null);
+    const human = summarizeQualifications(qualifications);
+    const result = {
+      lead_id: leadId,
+      qualification_summary: responses.length > 0 ? {
+        answered: responses.filter((r) => r.score != null).length,
+        total: responses.length,
+        avg_qualification_boost: avg
+      } : null,
+      qualifications,
+      signals_count: lastWf?.content ? Object.values(lastWf.content).reduce((acc, arr) => acc + (Array.isArray(arr) ? arr.length : 0), 0) : null,
+      _stillRunning: stillRunning
+    };
+    if (human)
+      result.human_summary = human;
+    return result;
+  }));
+  return {
+    results,
+    failed,
+    not_launched,
+    skipped_already_qualified,
+    not_in_lens: [...notInLens],
+    quota_exceeded: quotaExceeded,
+    cancelled
+  };
+}
+async function sleepWithAbort(ms, signal) {
+  if (!signal) {
+    await new Promise((r) => setTimeout(r, ms));
+    return;
+  }
+  if (signal.aborted)
+    return;
+  await new Promise((resolve) => {
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var PREQUALIFIED_CHUNK_SIZE = 25;
+async function prequalifiedLeads(client, leadIds, lensId, ctx) {
+  const already_qualified = /* @__PURE__ */ new Set();
+  const not_in_lens = /* @__PURE__ */ new Set();
+  for (let i = 0; i < leadIds.length; i += PREQUALIFIED_CHUNK_SIZE) {
+    const chunk = leadIds.slice(i, i + PREQUALIFIED_CHUNK_SIZE);
+    const results = await Promise.allSettled(chunk.map((leadId) => client.request("GET", `/lenses/${lensId}/leads/${leadId}`)));
+    let chunkSawQuota = false;
+    results.forEach((r, idx) => {
+      if (r.status !== "fulfilled") {
+        const code = r.reason?.code ?? r.reason?.message ?? "unknown";
+        if (code === "QUOTA_EXCEEDED")
+          chunkSawQuota = true;
+        if (code === "NOT_FOUND") {
+          not_in_lens.add(chunk[idx]);
+          return;
+        }
+        ctx?.logger?.warn?.(`qualify: prequalified GET failed for ${chunk[idx]}: ${code}`);
+        return;
+      }
+      const lead = r.value;
+      if (lead.ai_agent_lead_score != null && lead.web_fetch_in_progress !== true) {
+        already_qualified.add(lead.id);
+      }
+    });
+    if (chunkSawQuota) {
+      ctx?.logger?.warn?.(`qualify: prequalified preflight 429'd at chunk ${Math.floor(i / PREQUALIFIED_CHUNK_SIZE) + 1} \u2014 ${already_qualified.size} leads probed; remaining ${leadIds.length - (i + chunk.length)} leads will go through full fan-out`);
+      break;
+    }
+  }
+  return { already_qualified, not_in_lens };
+}
+function extractHintsAndCandidates(fileImport, catalog) {
+  const mapping_hints = [];
+  const hintsRaw = fileImport.pre_processing?.hints;
+  if (hintsRaw && typeof hintsRaw === "object" && hintsRaw.fields) {
+    for (const [col, h] of Object.entries(hintsRaw.fields)) {
+      mapping_hints.push({
+        column: col,
+        suggested_field: String(h?.field ?? ""),
+        ai_confidence: typeof h?.ai_confidence === "number" ? h.ai_confidence : null
+      });
+    }
+  }
+  const suggested = new Set(mapping_hints.map((m) => m.column));
+  const samplesRaw = fileImport.pre_processing?.samples ?? [];
+  const sample_rows = Array.isArray(samplesRaw) ? samplesRaw.slice(0, 50) : [];
+  const allColumns = /* @__PURE__ */ new Set();
+  for (const row of sample_rows) {
+    if (row && typeof row === "object") {
+      for (const k of Object.keys(row))
+        allColumns.add(k);
+    }
+  }
+  const norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const custom_field_candidates = [];
+  for (const col of allColumns) {
+    if (suggested.has(col))
+      continue;
+    const colNorm = norm(col);
+    const exact = catalog.filter((c) => c.name === col);
+    const ci = catalog.filter((c) => c.name.toLowerCase() === col.toLowerCase() && c.name !== col);
+    const seenIds = new Set([...exact, ...ci].map((c) => c.id));
+    const fuzzy = catalog.filter((c) => {
+      if (seenIds.has(c.id))
+        return false;
+      const n = norm(c.name);
+      return n.length > 0 && (n.includes(colNorm) || colNorm.includes(n));
+    });
+    if (exact.length === 0 && ci.length === 0 && fuzzy.length === 0)
+      continue;
+    custom_field_candidates.push({
+      column: col,
+      candidates: [
+        ...exact.map((c) => ({
+          id: c.id,
+          name: c.name,
+          type: c.type,
+          mapping_value: `CUSTOM.${c.id}`,
+          reason: "exact_name_match"
+        })),
+        ...ci.map((c) => ({
+          id: c.id,
+          name: c.name,
+          type: c.type,
+          mapping_value: `CUSTOM.${c.id}`,
+          reason: "case_insensitive_match"
+        })),
+        ...fuzzy.map((c) => ({
+          id: c.id,
+          name: c.name,
+          type: c.type,
+          mapping_value: `CUSTOM.${c.id}`,
+          reason: "fuzzy_substring_match"
+        }))
+      ]
+    });
+  }
+  return { mapping_hints, custom_field_candidates, sample_rows };
+}
+function fingerprintMapping(mapping) {
+  const sorted = Object.keys(mapping).sort();
+  const flat = sorted.map((k) => `${k}=${mapping[k]}`).join("|");
+  return createHash("sha256").update(flat).digest("hex").slice(0, 32);
+}
+async function refreshLeadStates(client, leadIds, questionOrder) {
+  return Promise.all(leadIds.map(async (leadId) => {
+    let lastQual = null;
+    let lastWf = null;
+    let wfErrorCode = null;
+    let qualErrorCode = null;
+    try {
+      const [wfR, qualR] = await Promise.allSettled([
+        client.request("GET", `/leads/${leadId}/web_fetch`),
+        client.request("GET", `/leads/${leadId}/ai_agent_responses`)
+      ]);
+      if (wfR.status === "fulfilled")
+        lastWf = wfR.value;
+      else
+        wfErrorCode = wfR.reason?.code ?? "UNKNOWN";
+      if (qualR.status === "fulfilled")
+        lastQual = qualR.value;
+      else
+        qualErrorCode = qualR.reason?.code ?? "UNKNOWN";
+    } catch {
+    }
+    const both404 = wfErrorCode === "NOT_FOUND" && qualErrorCode === "NOT_FOUND";
+    const stillRunning = !both404 && (lastWf?.in_progress === true || !lastQual || lastQual.length === 0 || lastQual.some((r) => r.score == null));
+    const responses = lastQual ?? [];
+    const scores = responses.map((r) => r.score).filter((s) => s != null);
+    const avg = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10 : null;
+    const qualifications = sortQualifications(responses.map((r) => {
+      const q = {
+        question: r.question,
+        score: r.score,
+        response: r.response,
+        computed_at: r.computed_at
+      };
+      if (r.outdated_at !== void 0)
+        q.outdated_at = r.outdated_at;
+      return q;
+    }), questionOrder ?? null);
+    const human = summarizeQualifications(qualifications);
+    const out = {
+      lead_id: leadId,
+      qualification_summary: responses.length > 0 ? {
+        answered: responses.filter((r) => r.score != null).length,
+        total: responses.length,
+        avg_qualification_boost: avg
+      } : null,
+      qualifications,
+      signals_count: lastWf?.content ? Object.values(lastWf.content).reduce((acc, arr) => acc + (Array.isArray(arr) ? arr.length : 0), 0) : null,
+      _stillRunning: stillRunning
+    };
+    if (human)
+      out.human_summary = human;
+    if (both404)
+      out._failedCode = "NOT_FOUND";
+    return out;
+  }));
+}
+
+// ../core/dist/composite/import-leads.js
+import { randomUUID } from "crypto";
+var CHUNK_SIZE = 100;
+var POLL_INTERVAL_MS2 = 2e3;
+var DEFAULT_PER_PHASE_BUDGET_MS = 6e4;
+var DEFAULT_TOTAL_BUDGET_MS = 3e5;
+var STABILIZATION_POLLS = 2;
+var MAX_COLUMN_NAME_LEN = 128;
+var RESERVED_COLUMN_RE = /^mcp_row_id$/i;
+var CUSTOM_FIELD_RE = /^CUSTOM\.(\d+)$/;
+function isCustomFieldMappingValue(v) {
+  return CUSTOM_FIELD_RE.test(v);
+}
+function customFieldIdOf(v) {
+  const m = CUSTOM_FIELD_RE.exec(v);
+  return m ? m[1] : null;
+}
+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(header, rows) {
+  const headerLine = header.map(escapeCsvCell).join(",");
+  const dataLines = rows.map((r) => header.map((col) => escapeCsvCell(r[col] ?? "")).join(","));
+  return [headerLine, ...dataLines].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 sleepWithAbort2(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 validateColumnName(client, name, path) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} must be a non-empty string`, `Use a plain string column name (1-${MAX_COLUMN_NAME_LEN} chars).`, "POST /imports");
+  }
+  if (name.length > MAX_COLUMN_NAME_LEN) {
+    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} exceeds ${MAX_COLUMN_NAME_LEN} chars`, `Shorten the column name to ${MAX_COLUMN_NAME_LEN} chars or fewer.`, "POST /imports");
+  }
+  if (/[\x00-\x1F\x7F]/.test(name)) {
+    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} contains control characters`, `Strip control characters (e.g. \\n, \\t, \\x00) from column names.`, "POST /imports");
+  }
+}
+function coerceCell(client, v, path) {
+  if (v == null)
+    return "";
+  if (typeof v === "string")
+    return v;
+  if (typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  throw client.makeError("IMPORT_INVALID_CELL_TYPE", `Cell at ${path} is ${Array.isArray(v) ? "an array" : typeof v}, expected string|number|boolean|null`, `Convert the value to a string before passing.`, "POST /imports");
+}
+function prepareDomainsMode(client, inputs) {
+  const validInputs = [];
+  const malformedDomains = [];
+  const byDomain = /* @__PURE__ */ new Map();
+  const byRowId = /* @__PURE__ */ new Map();
+  for (const inp of inputs) {
+    const norm = normalizeDomain(inp?.domain ?? "");
+    if (!norm) {
+      malformedDomains.push(inp?.domain ?? "");
+      continue;
+    }
+    if (byDomain.has(norm))
+      continue;
+    const rowId = randomUUID();
+    const idx = validInputs.length;
+    const name = inp.name?.trim() || norm;
+    validInputs.push({
+      index: idx,
+      rowId,
+      row: { MCP_ROW_ID: rowId, LEAD_NAME: name, LEAD_WEBSITE: norm },
+      domain: norm,
+      outputDomain: norm
+    });
+    byDomain.set(norm, idx);
+    byRowId.set(rowId, idx);
+  }
+  return {
+    mode: "domains",
+    validInputs,
+    malformedDomains,
+    byDomain,
+    byRowId,
+    header: ["MCP_ROW_ID", "LEAD_NAME", "LEAD_WEBSITE"],
+    mappings: {
+      fields: { LEAD_NAME: "LEAD_NAME", LEAD_WEBSITE: "LEAD_WEBSITE" },
+      statuses: {},
+      default_status: null
+    }
+  };
+}
+function prepareRecordsMode(client, records, mappings, customFieldCatalog) {
+  if (!mappings || !mappings.fields || typeof mappings.fields !== "object") {
+    throw client.makeError("IMPORT_MAPPING_REQUIRED", "records[] requires a mappings.fields object", "Pass `mappings: { fields: { CsvColumn: 'LEAD_NAME', ... } }`.", "POST /imports");
+  }
+  const normalizedFields = normalizeFieldsAndCustomShorthand(client, mappings.fields, mappings.custom_fields, customFieldCatalog);
+  const fieldEntries = Object.entries(normalizedFields);
+  if (fieldEntries.length === 0) {
+    throw client.makeError("IMPORT_MAPPING_REQUIRED", "mappings.fields must contain at least one column \u2192 CRM field entry", "Map at least one CSV column to LEAD_NAME or LEAD_WEBSITE.", "POST /imports");
+  }
+  const targets = new Set(fieldEntries.map(([, v]) => v));
+  if (!targets.has("LEAD_NAME") && !targets.has("LEAD_WEBSITE")) {
+    throw client.makeError("IMPORT_MAPPING_NO_RESOLVER", "mappings.fields must include LEAD_NAME or LEAD_WEBSITE", "The wizard needs at least one of those fields to match a lead. Map a CSV column to one of them.", "POST /imports");
+  }
+  const targetCounts = /* @__PURE__ */ new Map();
+  for (const [col, target] of fieldEntries) {
+    if (typeof target !== "string")
+      continue;
+    if (target.startsWith("CUSTOM."))
+      continue;
+    const cols = targetCounts.get(target) ?? [];
+    cols.push(col);
+    targetCounts.set(target, cols);
+  }
+  for (const [target, cols] of targetCounts) {
+    if (cols.length > 1) {
+      throw client.makeError("IMPORT_MAPPING_CONFLICT_TARGET", `Multiple columns map to the same target ${target}: ${cols.map((c) => JSON.stringify(c)).join(", ")}`, `Each StandardCrmFieldType can be the destination of only one column (the wizard would silently keep one and drop the others). Pick the column you want and remove the duplicates.`, "POST /imports");
+    }
+  }
+  for (const [colName] of fieldEntries) {
+    validateColumnName(client, colName, `mappings.fields[${JSON.stringify(colName)}]`);
+    if (RESERVED_COLUMN_RE.test(colName)) {
+      throw client.makeError("IMPORT_RESERVED_COLUMN", `mappings.fields key '${colName}' collides with reserved synthetic column MCP_ROW_ID`, `Rename the column. MCP_ROW_ID (any case) is reserved for tool-internal reconciliation.`, "POST /imports");
+    }
+  }
+  const headerSet = /* @__PURE__ */ new Set();
+  const coercedRecords = [];
+  records.forEach((rec, i) => {
+    if (rec == null || typeof rec !== "object" || Array.isArray(rec)) {
+      throw client.makeError("IMPORT_INVALID_CELL_TYPE", `records[${i}] must be a plain object`, `Pass each record as { ColumnName: value, ... }.`, "POST /imports");
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(rec)) {
+      validateColumnName(client, k, `records[${i}] key`);
+      if (RESERVED_COLUMN_RE.test(k)) {
+        throw client.makeError("IMPORT_RESERVED_COLUMN", `records[${i}] key '${k}' collides with reserved synthetic column MCP_ROW_ID`, `Rename the column in your records (any case variant of MCP_ROW_ID is reserved).`, "POST /imports");
+      }
+      out[k] = coerceCell(client, v, `records[${i}].${k}`);
+      headerSet.add(k);
+    }
+    coercedRecords.push(out);
+  });
+  for (const [colName] of fieldEntries) {
+    if (!headerSet.has(colName)) {
+      throw client.makeError("IMPORT_MAPPING_KEY_UNKNOWN", `mappings.fields key '${colName}' is not present in any record`, `Add a value for '${colName}' to at least one record, or remove it from mappings.`, "POST /imports");
+    }
+  }
+  const userKeys = [...headerSet].sort();
+  const header = ["MCP_ROW_ID", ...userKeys];
+  const websiteCol = fieldEntries.find(([, v]) => v === "LEAD_WEBSITE")?.[0];
+  const validInputs = [];
+  const byDomain = /* @__PURE__ */ new Map();
+  const byRowId = /* @__PURE__ */ new Map();
+  coercedRecords.forEach((row) => {
+    const rowId = randomUUID();
+    const idx = validInputs.length;
+    let normDomain = null;
+    if (websiteCol) {
+      normDomain = normalizeDomain(row[websiteCol] ?? "");
+    }
+    const fullRow = { MCP_ROW_ID: rowId, ...row };
+    validInputs.push({
+      index: idx,
+      rowId,
+      row: fullRow,
+      domain: normDomain,
+      outputDomain: normDomain ?? void 0
+    });
+    byRowId.set(rowId, idx);
+    if (normDomain && !byDomain.has(normDomain))
+      byDomain.set(normDomain, idx);
+  });
+  return {
+    mode: "records",
+    validInputs,
+    malformedDomains: [],
+    byDomain,
+    byRowId,
+    header,
+    mappings: {
+      fields: { ...normalizedFields },
+      statuses: mappings.statuses ?? {},
+      default_status: mappings.default_status ?? null
+    }
+  };
+}
+function normalizeFieldsAndCustomShorthand(client, fields, customShorthand, catalog) {
+  const out = {};
+  const seenColumns = /* @__PURE__ */ new Set();
+  for (const [col, raw] of Object.entries(fields)) {
+    if (typeof raw !== "string") {
+      throw client.makeError("IMPORT_INVALID_CUSTOM_MAPPING", `mappings.fields[${JSON.stringify(col)}] must be a string (got ${typeof raw})`, "Pass a StandardCrmFieldType name (e.g. 'LEAD_NAME') or 'CUSTOM.<id>'.", "POST /imports");
+    }
+    if (raw.startsWith("CUSTOM.")) {
+      if (!isCustomFieldMappingValue(raw)) {
+        throw client.makeError("IMPORT_INVALID_CUSTOM_MAPPING", `mappings.fields[${JSON.stringify(col)}] = ${JSON.stringify(raw)} is not a well-formed custom mapping`, "Custom field mappings must look like 'CUSTOM.<digits>'. Call leadbay_list_mappable_fields to see valid ids.", "POST /imports");
+      }
+      if (catalog !== null) {
+        const id = customFieldIdOf(raw);
+        const found = catalog.find((c) => c.id === id);
+        if (!found) {
+          throw client.makeError("IMPORT_CUSTOM_FIELD_UNKNOWN", `mappings.fields[${JSON.stringify(col)}] = ${JSON.stringify(raw)} references custom field id ${id}, not present on this org`, `Org has ${catalog.length} custom field(s): ${catalog.length === 0 ? "none \u2014 create one in the Leadbay web UI first" : catalog.map((c) => `${c.id}=${c.name} (${c.type})`).join(", ")}`, "POST /imports");
+        }
+      }
+    }
+    out[col] = raw;
+    seenColumns.add(col);
+  }
+  if (customShorthand && Object.keys(customShorthand).length > 0) {
+    if (catalog === null) {
+      throw client.makeError("IMPORT_CUSTOM_FIELD_CATALOG_REQUIRED", "mappings.custom_fields shorthand requires the org's custom-field catalog", "This is an internal error \u2014 the composite should have fetched /crm/custom_fields. Retry, or use raw 'CUSTOM.<id>' in mappings.fields.", "POST /imports");
+    }
+    for (const [col, val] of Object.entries(customShorthand)) {
+      if (seenColumns.has(col)) {
+        throw client.makeError("IMPORT_MAPPING_DUPLICATE_CUSTOM", `Column ${JSON.stringify(col)} is in BOTH mappings.fields and mappings.custom_fields`, "Each column maps to exactly one field. Drop the duplicate from one of the two maps.", "POST /imports");
+      }
+      let resolved;
+      const numericVal = typeof val === "number" ? val : typeof val === "string" && /^\d+$/.test(val) ? Number(val) : null;
+      if (numericVal !== null) {
+        const idStr = String(numericVal);
+        resolved = catalog.find((c) => c.id === idStr);
+        if (!resolved) {
+          throw client.makeError("IMPORT_CUSTOM_FIELD_UNKNOWN", `mappings.custom_fields[${JSON.stringify(col)}] = ${val} is not a custom field on this org`, `Org has ${catalog.length} custom field(s): ${catalog.length === 0 ? "none \u2014 create one in the Leadbay web UI first" : catalog.map((c) => `${c.id}=${c.name} (${c.type})`).join(", ")}`, "POST /imports");
+        }
+      } else if (typeof val === "string") {
+        const matches = catalog.filter((c) => c.name === val);
+        if (matches.length === 0) {
+          const ci = catalog.filter((c) => c.name.toLowerCase() === val.toLowerCase());
+          if (ci.length === 0) {
+            throw client.makeError("IMPORT_CUSTOM_FIELD_UNKNOWN", `mappings.custom_fields[${JSON.stringify(col)}] = ${JSON.stringify(val)} doesn't match any custom field name`, `Org has ${catalog.length} custom field(s): ${catalog.length === 0 ? "none \u2014 create one in the Leadbay web UI first" : catalog.map((c) => `${c.id}=${c.name} (${c.type})`).join(", ")}`, "POST /imports");
+          }
+          if (ci.length > 1) {
+            throw client.makeError("IMPORT_CUSTOM_FIELD_NAME_AMBIGUOUS", `mappings.custom_fields[${JSON.stringify(col)}] = ${JSON.stringify(val)} matches ${ci.length} custom fields case-insensitively`, `Pass the numeric id instead. Candidates: ${ci.map((c) => `${c.id}=${c.name}`).join(", ")}`, "POST /imports");
+          }
+          resolved = ci[0];
+        } else if (matches.length > 1) {
+          throw client.makeError("IMPORT_CUSTOM_FIELD_NAME_AMBIGUOUS", `mappings.custom_fields[${JSON.stringify(col)}] = ${JSON.stringify(val)} matches ${matches.length} custom fields exactly`, `Pass the numeric id instead. Candidates: ${matches.map((c) => `${c.id}=${c.name}`).join(", ")}`, "POST /imports");
+        } else {
+          resolved = matches[0];
+        }
+      } else {
+        throw client.makeError("IMPORT_INVALID_CUSTOM_MAPPING", `mappings.custom_fields[${JSON.stringify(col)}] must be a number (id) or string (name); got ${typeof val}`, "Pass either the numeric id (e.g. 8) or the field name (e.g. 'priority').", "POST /imports");
+      }
+      out[col] = `CUSTOM.${resolved.id}`;
+      seenColumns.add(col);
+    }
+  }
+  return out;
+}
+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 sleepWithAbort2(POLL_INTERVAL_MS2, 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 input in 30s, or split the batch. importId=${importId}.`, `GET /imports/${importId}/records`);
+    }
+    await sleepWithAbort2(POLL_INTERVAL_MS2, signal);
+  }
+}
+async function runOneChunk(client, chunk, chunkIdx, totalChunks, header, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onImportId) {
+  const csv = synthesizeCsv(header, chunk.map((c) => c.row));
+  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: [] };
+  }
+  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(prep, chunk, 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 && prep.byRowId.has(rowIdCell)) {
+      inputIdx = prep.byRowId.get(rowIdCell);
+    }
+    if (inputIdx === void 0) {
+      const websiteCell = readCell(rec, "LEAD_WEBSITE");
+      if (websiteCell) {
+        const norm = normalizeDomain(websiteCell);
+        if (norm && prep.byDomain.has(norm)) {
+          inputIdx = prep.byDomain.get(norm);
+        }
+      }
+    }
+    if (inputIdx === void 0 && rec.lead?.website) {
+      const norm = normalizeDomain(rec.lead.website);
+      if (norm && prep.byDomain.has(norm)) {
+        inputIdx = prep.byDomain.get(norm);
+      }
+    }
+    if (inputIdx === void 0)
+      continue;
+    if (seenInputIndex.has(inputIdx)) {
+      if (!matched.has(inputIdx) && !notImported.has(inputIdx)) {
+        const inp2 = prep.validInputs[inputIdx];
+        notImported.set(inputIdx, { domain: inp2.outputDomain, reason: "ambiguous" });
+      }
+      continue;
+    }
+    seenInputIndex.add(inputIdx);
+    const inp = prep.validInputs[inputIdx];
+    const matchType = (rec.match_type ?? rec.matchType ?? "").toString();
+    if (rec.lead?.id) {
+      matched.set(inputIdx, {
+        domain: inp.outputDomain,
+        leadId: rec.lead.id,
+        name: rec.lead.name ?? null
+      });
+    } else if (matchType === "NO_MATCH") {
+      const reason = inp.domain && PUBLIC_MAILBOX_DOMAINS.has(inp.domain) ? "no_match" : "uncrawled";
+      notImported.set(inputIdx, { domain: inp.outputDomain, reason });
+    } else {
+      notImported.set(inputIdx, { domain: inp.outputDomain, reason: "internal_error" });
+    }
+  }
+}
+var importLeads = {
+  name: "leadbay_import_leads",
+  description: "Import leads into Leadbay's CRM via the file-import wizard. Returns stable Leadbay leadIds for downstream chaining into leadbay_bulk_qualify_leads / leadbay_research_lead.\n\nTWO MODES:\n  A) Domain-list shortcut \u2014 pass `domains: [{domain, name?}]`. The tool builds a 2-column CSV (LEAD_NAME, LEAD_WEBSITE) and imports with the default mapping. Output: { leads: [{domain, leadId, name}], not_imported: [{domain, reason}], importIds, _meta }.\n  B) Custom records + mapping \u2014 pass `records: [{Col1, Col2, ...}]` plus `mappings.fields: {Col1: 'LEAD_NAME', Col2: 'LEAD_WEBSITE', ...}`. The tool synthesizes a CSV from the union of record keys (deterministic order) and POSTs the caller-supplied mapping to the wizard. mappings.fields must include LEAD_NAME or LEAD_WEBSITE (the resolver needs at least one). Output: { leads: [{rowId, domain?, leadId, name}], not_imported: [{rowId, domain?, reason}], importIds, _meta }. `rowId` round-trips your input order.\n\nPass exactly one of `domains` / `records`. Reserved column MCP_ROW_ID (any case) cannot appear in records or mappings \u2014 the tool injects it for stable reconciliation.\n\n\u26A0\uFE0F MUTATES USER STATE. 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\n\u2139\uFE0F Monitor-tab membership: imported leads are NOT auto-promoted to the user's Monitor view. Lens-scoring decides \u2014 only above-threshold leads get `in_monitor: true` server-side.\n\nWhen to use: you have a list of company domains from another system (CRM, analytics, email correspondents) and need stable Leadbay leadIds; or you have CRM-shaped rows with custom columns (sector, location, status, etc.) and want to drive the wizard with explicit field mappings.\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\nCustom fields: pass org-defined custom field mappings as 'CUSTOM.<id>' (raw wire format) in `mappings.fields`, OR use the ergonomic `mappings.custom_fields` shorthand: `{ColName: 8}` (numeric id) or `{ColName: 'priority_test'}` (field name). Discover available custom fields via leadbay_list_mappable_fields.\n\nRequires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role on the Leadbay account; active billing.",
+  write: true,
+  version: "0.3.0",
+  inputSchema: {
+    type: "object",
+    properties: {
+      domains: {
+        type: "array",
+        description: "Mode A: list of company domains to map to Leadbay leadIds. Mutually exclusive with `records`.",
+        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"]
+        }
+      },
+      records: {
+        type: "array",
+        description: "Mode B: arbitrary CSV-shaped rows. Each record is an object whose keys are column names and values are scalar (string/number/boolean/null). Mutually exclusive with `domains`. Must be accompanied by `mappings.fields`. The tool synthesizes a CSV from the union of all record keys.",
+        items: { type: "object" }
+      },
+      mappings: {
+        type: "object",
+        description: "Mode B: how each CSV column maps to Leadbay's CRM field schema. Required when `records` is supplied; ignored otherwise.",
+        properties: {
+          fields: {
+            type: "object",
+            description: "Object whose keys are CSV column names (matching keys in `records`) and whose values are either Leadbay's StandardCrmFieldType (LEAD_NAME, LEAD_WEBSITE, LEAD_STATUS, LEAD_LOCATION, LEAD_LOCATION_*, LEAD_SECTOR, LEAD_SIZE, CRM_ID, LEADBAY_ID, EMAIL, DEAL_CRM_ID, CONTACT_FIRST_NAME, CONTACT_LAST_NAME, CONTACT_EMAIL, CONTACT_PHONE_NUMBER, CONTACT_TITLE, CONTACT_LINKEDIN, LEAD_STATUS_DATE, OWNER, SCORE, SIREN) or the wire-format string 'CUSTOM.<id>' for org-defined custom fields. At least one entry must target LEAD_NAME or LEAD_WEBSITE \u2014 the wizard needs that to find leads. Use leadbay_list_mappable_fields to discover the org's custom fields."
+          },
+          custom_fields: {
+            type: "object",
+            description: "Ergonomic shorthand: `{CsvColumn: <number-id>}` or `{CsvColumn: '<field-name>'}` for custom-field mappings. Resolved against the org's /crm/custom_fields catalog before the import is committed. Mutually exclusive with `fields[col] = 'CUSTOM.<id>'` for the same column. Useful when the agent doesn't want to deal with the 'CUSTOM.<id>' wire format."
+          },
+          statuses: {
+            type: "object",
+            description: "Optional status string mapping (rarely needed). Defaults to {}."
+          },
+          default_status: {
+            type: ["string", "null"],
+            description: "Optional default status. Defaults to null."
+          }
+        },
+        required: ["fields"]
+      },
+      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 input 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_MS}ms).`
+      }
+    }
+    // Neither field is "required" at the schema level; xor + presence is
+    // enforced in execute() so we can produce specific error codes.
+  },
+  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_MS;
+    const totalDeadline = Date.now() + totalBudget;
+    const hasDomains = Array.isArray(params.domains) && params.domains.length > 0;
+    const hasRecords = Array.isArray(params.records) && params.records.length > 0;
+    if (hasDomains && hasRecords) {
+      throw client.makeError("IMPORT_INPUT_CONFLICT", "Pass exactly one of `domains` or `records`, not both", "Use `domains` for the simple shortcut, or `records`+`mappings` for arbitrary CSV input.", "POST /imports");
+    }
+    if (!hasDomains && !hasRecords) {
+      throw client.makeError("IMPORT_EMPTY_INPUT", "domains[] or records[] must contain at least one entry", "Pass at least one entry. See the tool description for the two input modes.", "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");
+    }
+    let customFieldCatalog = null;
+    if (hasRecords) {
+      const m = params.mappings;
+      const referencesCustom = m?.custom_fields && Object.keys(m.custom_fields).length > 0 || m?.fields && Object.values(m.fields).some((v) => typeof v === "string" && v.startsWith("CUSTOM."));
+      if (referencesCustom) {
+        try {
+          customFieldCatalog = await client.request("GET", "/crm/custom_fields");
+        } catch (err) {
+          throw client.makeError("IMPORT_CUSTOM_FIELD_CATALOG_UNAVAILABLE", `Failed to fetch /crm/custom_fields for preflight: ${err?.message ?? err?.code ?? "unknown"}`, "Custom field references can't be validated. Retry, or remove custom-field mappings.", "GET /crm/custom_fields");
+        }
+      }
+    }
+    const prep = hasDomains ? prepareDomainsMode(client, params.domains) : prepareRecordsMode(client, params.records, params.mappings, customFieldCatalog);
+    if (prep.validInputs.length === 0) {
+      const not_imported2 = prep.malformedDomains.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(prep.validInputs);
+    ctx?.logger?.info?.(`import-leads(${prep.mode}): ${prep.validInputs.length} rows \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, prep.header, prep.mappings, dryRun, perPhaseBudget, totalDeadline, ctx, signal, recordImportId);
+        if (!dryRun) {
+          reconcileOneChunk(prep, out, matched, notImported);
+        }
+      }
+    } 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;
+      }
+    }
+    const leads = [];
+    const not_imported = [];
+    if (dryRun) {
+      for (const inp of prep.validInputs) {
+        if (prep.mode === "domains") {
+          not_imported.push({ domain: inp.outputDomain, reason: "dry_run" });
+        } else {
+          const entry = { rowId: inp.rowId, reason: "dry_run" };
+          if (inp.outputDomain)
+            entry.domain = inp.outputDomain;
+          not_imported.push(entry);
+        }
+      }
+    } else {
+      for (const inp of prep.validInputs) {
+        const m = matched.get(inp.index);
+        if (m) {
+          if (prep.mode === "domains") {
+            leads.push({
+              domain: inp.outputDomain,
+              leadId: m.leadId,
+              name: m.name
+            });
+          } else {
+            const e = {
+              rowId: inp.rowId,
+              leadId: m.leadId,
+              name: m.name
+            };
+            if (m.domain ?? inp.outputDomain)
+              e.domain = m.domain ?? inp.outputDomain;
+            leads.push(e);
+          }
+          continue;
+        }
+        const ni = notImported.get(inp.index);
+        if (ni) {
+          if (prep.mode === "domains") {
+            not_imported.push({ domain: inp.outputDomain, reason: ni.reason });
+          } else {
+            const e = { rowId: inp.rowId, reason: ni.reason };
+            if (ni.domain ?? inp.outputDomain)
+              e.domain = ni.domain ?? inp.outputDomain;
+            not_imported.push(e);
+          }
+          continue;
+        }
+        if (prep.mode === "domains") {
+          not_imported.push({ domain: inp.outputDomain, reason: "internal_error" });
+        } else {
+          const e = { rowId: inp.rowId, reason: "internal_error" };
+          if (inp.outputDomain)
+            e.domain = inp.outputDomain;
+          not_imported.push(e);
+        }
+      }
+    }
+    for (const m of prep.malformedDomains) {
+      not_imported.push({ domain: m, reason: "malformed" });
+    }
+    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/tools/list-mappable-fields.js
+var STANDARD_FIELDS = [
+  { name: "LEAD_NAME", description: "Company name. Required for fuzzy match." },
+  { name: "LEAD_WEBSITE", description: "Company domain (preferred matcher; protocol/path auto-stripped)." },
+  { name: "EMAIL", description: "Email \u2014 domain part used as a website-fallback matcher." },
+  { name: "CRM_ID", description: "Your CRM's stable lead identifier (round-trips back as crm_id on the lead)." },
+  { name: "LEADBAY_ID", description: "Leadbay UUID, if you already have one (matches by id, no fuzzy needed)." },
+  { name: "DEAL_CRM_ID", description: "Your CRM's deal id (one deal per row; combined with LEAD_STATUS forms a sales record)." },
+  { name: "LEAD_STATUS", description: "Free-form status string (use mappings.statuses to map per-status)." },
+  { name: "LEAD_STATUS_DATE", description: "ISO date for the LEAD_STATUS transition (parsed permissively)." },
+  { name: "LEAD_SECTOR", description: "Industry/sector free-text (matched against Leadbay's sector taxonomy)." },
+  { name: "LEAD_SIZE", description: "Headcount or revenue range as free text." },
+  { name: "LEAD_LOCATION", description: "Single-cell address (preferred when CSV has one column)." },
+  { name: "LEAD_LOCATION_STREET_NUM", description: "Street number \u2014 combined with the other LEAD_LOCATION_* parts to form the address." },
+  { name: "LEAD_LOCATION_STREET", description: "Street name." },
+  { name: "LEAD_LOCATION_POSTCODE", description: "Postal/ZIP code." },
+  { name: "LEAD_LOCATION_CITY", description: "City." },
+  { name: "OWNER", description: "Free-text owner identifier (no auto-match against users)." },
+  { name: "SCORE", description: "Free-text caller-supplied score (informational only \u2014 NOT Leadbay's ai_agent_lead_score)." },
+  { name: "SIREN", description: "French SIREN registry number (9 digits) \u2014 auto-matches against the FR registry." },
+  { name: "CONTACT_FIRST_NAME", description: "Contact first name (creates an org contact)." },
+  { name: "CONTACT_LAST_NAME", description: "Contact last name." },
+  { name: "CONTACT_EMAIL", description: "Contact email." },
+  { name: "CONTACT_PHONE_NUMBER", description: "Contact phone (free-form)." },
+  { name: "CONTACT_TITLE", description: "Contact job title." },
+  { name: "CONTACT_LINKEDIN", description: "Contact LinkedIn URL." }
+];
+function describeCustomField(f) {
+  switch (f.type) {
+    case "TEXT":
+      return `Custom TEXT field \u2014 free-form string.`;
+    case "NUMBER":
+      return `Custom NUMBER field \u2014 numeric value (parseFloat coerced server-side).`;
+    case "PRICE":
+      return `Custom PRICE field${f.config?.currency ? ` (${f.config.currency})` : ""} \u2014 numeric.`;
+    case "DATE":
+      return `Custom DATE field${f.config?.format ? ` (format: ${f.config.format})` : " (ISO yyyy-MM-dd)"}.`;
+    case "DATETIME":
+      return `Custom DATETIME field${f.config?.format ? ` (format: ${f.config.format})` : " (ISO datetime)"}.`;
+    case "EXTERNAL_ID":
+      return `Custom EXTERNAL_ID field \u2014 opaque id${f.config?.urlTemplate ? ` (deep-link template configured)` : ""}.`;
+    default:
+      return `Custom field of unrecognized type "${f.type}" \u2014 pass values as strings.`;
+  }
+}
+var PREVIEW_SAMPLE_CAP = 50;
+var PREPROCESS_BUDGET_MS = 6e4;
+var listMappableFields = {
+  name: "leadbay_list_mappable_fields",
+  description: "List every CRM field the agent can target when calling leadbay_import_leads or leadbay_import_and_qualify. Returns two arrays: `standard_fields` (Leadbay's built-in StandardCrmFieldType enum \u2014 LEAD_NAME, LEAD_WEBSITE, LEAD_STATUS, contact + location + sector fields) and `custom_fields` (this org's user-defined fields \u2014 id, name, type, and the literal `mapping_value` you pass in `mappings.fields`). For custom fields, `mapping_value` is the wire-format string `CUSTOM.<id>` \u2014 pass it verbatim.\n\nOptional `for_records` param: pass a sample of CSV-shaped rows and the tool also runs the wizard's preprocess on them, attaching `mapping_hints` (per-column AI-confidence suggestions) and `custom_field_candidates` (custom fields that match unmapped columns by exact / case-insensitive / fuzzy name) to the response. Saves a separate preview round-trip when the agent already has data in hand.\n\nWhen to use: before authoring an import mapping, especially when the CSV has columns that aren't obvious matches for standard fields. When NOT to use: when you already know the mapping \u2014 this call is cheap (~50ms with no for_records, ~5\u201310s with) but unnecessary if the agent has already cached the catalog within the same conversation.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      for_records: {
+        type: "array",
+        items: { type: "object" },
+        description: "Optional sample of CSV-shaped rows (objects). When provided, the tool runs the wizard's preprocess on the first 50 rows and attaches mapping_hints + custom_field_candidates to the response."
+      }
+    },
+    additionalProperties: false
+  },
+  execute: async (client, params, ctx) => {
+    const signal = ctx?.signal;
+    const customs = await client.request("GET", "/crm/custom_fields");
+    const standard_fields = STANDARD_FIELDS.map((s) => ({
+      name: s.name,
+      description: s.description,
+      mapping_value: s.name
+    }));
+    const catalog = customs ?? [];
+    const custom_fields = catalog.map((f) => ({
+      id: f.id,
+      name: f.name,
+      type: f.type,
+      description: describeCustomField(f),
+      mapping_value: `CUSTOM.${f.id}`
+    }));
+    const result = {
+      standard_fields,
+      custom_fields,
+      region: client.region,
+      _meta: client.lastMeta ?? {
+        region: client.region,
+        endpoint: "GET /crm/custom_fields",
+        latency_ms: null,
+        retry_after: null
+      }
+    };
+    if (Array.isArray(params.for_records) && params.for_records.length > 0) {
+      const notes = [];
+      try {
+        const sample = params.for_records.slice(0, PREVIEW_SAMPLE_CAP);
+        const headerSet = /* @__PURE__ */ new Set();
+        for (const r of sample)
+          if (r && typeof r === "object")
+            for (const k of Object.keys(r))
+              headerSet.add(k);
+        const header = [...headerSet];
+        const lines = [header.map(escapeCsvCell).join(",")];
+        for (const r of sample) {
+          lines.push(header.map((c) => escapeCsvCell(coerceCsvValue(r[c]))).join(","));
+        }
+        const csv = lines.join("\n") + "\n";
+        const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        const fileName = `mcp-preview-${ts}.csv`;
+        const upload = await client.requestRawBinary("POST", `/imports?file_name=${encodeURIComponent(fileName)}`, "text/csv", csv);
+        const importId = upload.id;
+        const deadline = Date.now() + PREPROCESS_BUDGET_MS;
+        let fileImport = null;
+        while (Date.now() < deadline) {
+          if (signal?.aborted) {
+            throw Object.assign(new Error("aborted"), { name: "AbortError" });
+          }
+          const r = await client.request("GET", `/imports/${importId}`);
+          if (r.pre_processing?.finished) {
+            fileImport = r;
+            break;
+          }
+          await new Promise((res) => {
+            const t = setTimeout(() => {
+              signal?.removeEventListener("abort", onAbort);
+              res();
+            }, 2e3);
+            const onAbort = () => {
+              clearTimeout(t);
+              signal?.removeEventListener("abort", onAbort);
+              res();
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+          });
+          if (signal?.aborted) {
+            throw Object.assign(new Error("aborted"), { name: "AbortError" });
+          }
+        }
+        if (!fileImport) {
+          notes.push(`for_records preprocess did not finish within ${PREPROCESS_BUDGET_MS}ms \u2014 hints omitted`);
+        } else if (fileImport.pre_processing?.error) {
+          notes.push(`for_records preprocess failed: ${fileImport.pre_processing.error}`);
+        } else {
+          const extracted = extractHintsAndCandidates(fileImport, catalog);
+          result.mapping_hints = extracted.mapping_hints;
+          result.custom_field_candidates = extracted.custom_field_candidates;
+          result.sample_rows = extracted.sample_rows;
+        }
+      } catch (err) {
+        notes.push(`for_records preprocess error: ${err?.code ?? err?.message ?? "unknown"} \u2014 hints omitted`);
+      }
+      if (notes.length > 0)
+        result.notes = notes;
+    }
+    return result;
+  }
+};
+function coerceCsvValue(v) {
+  if (v == null)
+    return "";
+  if (typeof v === "string")
+    return v;
+  if (typeof v === "number" || typeof v === "boolean")
+    return String(v);
+  return "";
+}
+
 // ../core/dist/tools/select-leads.js
 var selectLeads = {
   name: "leadbay_select_leads",
@@ -2128,7 +3416,7 @@ var PAGE_SIZE = 50;
 var DEFAULT_COUNT = 10;
 var MAX_COUNT = 25;
 var DEFAULT_PER_LEAD_BUDGET_MS = 9e4;
-var DEFAULT_TOTAL_BUDGET_MS = 5 * 6e4;
+var DEFAULT_TOTAL_BUDGET_MS2 = 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. 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).",
@@ -2154,14 +3442,14 @@ var bulkQualifyLeads = {
       },
       total_budget_ms: {
         type: "number",
-        description: `Total polling budget in ms (default ${DEFAULT_TOTAL_BUDGET_MS})`
+        description: `Total polling budget in ms (default ${DEFAULT_TOTAL_BUDGET_MS2})`
       }
     }
   },
   execute: async (client, params, ctx) => {
     const wantCount = Math.min(params.count ?? DEFAULT_COUNT, MAX_COUNT);
     const perLeadBudget = params.per_lead_budget_ms ?? DEFAULT_PER_LEAD_BUDGET_MS;
-    const totalBudget = params.total_budget_ms ?? DEFAULT_TOTAL_BUDGET_MS;
+    const totalBudget = params.total_budget_ms ?? DEFAULT_TOTAL_BUDGET_MS2;
     const totalDeadline = Date.now() + totalBudget;
     let candidates;
     let exhausted = false;
@@ -2250,502 +3538,143 @@ var bulkQualifyLeads = {
         await new Promise((r) => setTimeout(r, 5e3));
       }
       const stillRunning = lastWf?.in_progress === true || !lastQual || lastQual.length === 0 || lastQual.some((r) => r.score == null);
-      const responses = lastQual ?? [];
-      const scores = responses.map((r) => r.score).filter((s) => s != null);
-      const avg = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10 : null;
-      return {
-        lead_id: leadId,
-        qualification_summary: responses.length > 0 ? {
-          answered: responses.filter((r) => r.score != null).length,
-          total: responses.length,
-          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
-      };
-    }));
-    const qualified = results.filter((r) => !r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
-    const still_running = results.filter((r) => r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
-    return {
-      qualified,
-      still_running,
-      failed,
-      quota_exceeded: quotaExceeded,
-      exhausted,
-      total_unqualified_found: totalUnqualifiedFound,
-      lens_id: lensId,
-      _meta: { region: client.region }
-    };
-  }
-};
-
-// ../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 MAX_COLUMN_NAME_LEN = 128;
-var RESERVED_COLUMN_RE = /^mcp_row_id$/i;
-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(header, rows) {
-  const headerLine = header.map(escapeCsvCell).join(",");
-  const dataLines = rows.map((r) => header.map((col) => escapeCsvCell(r[col] ?? "")).join(","));
-  return [headerLine, ...dataLines].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 validateColumnName(client, name, path) {
-  if (typeof name !== "string" || name.length === 0) {
-    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} must be a non-empty string`, `Use a plain string column name (1-${MAX_COLUMN_NAME_LEN} chars).`, "POST /imports");
-  }
-  if (name.length > MAX_COLUMN_NAME_LEN) {
-    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} exceeds ${MAX_COLUMN_NAME_LEN} chars`, `Shorten the column name to ${MAX_COLUMN_NAME_LEN} chars or fewer.`, "POST /imports");
-  }
-  if (/[\x00-\x1F\x7F]/.test(name)) {
-    throw client.makeError("IMPORT_INVALID_COLUMN_NAME", `Column name at ${path} contains control characters`, `Strip control characters (e.g. \\n, \\t, \\x00) from column names.`, "POST /imports");
+      const responses = lastQual ?? [];
+      const scores = responses.map((r) => r.score).filter((s) => s != null);
+      const avg = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10 : null;
+      return {
+        lead_id: leadId,
+        qualification_summary: responses.length > 0 ? {
+          answered: responses.filter((r) => r.score != null).length,
+          total: responses.length,
+          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
+      };
+    }));
+    const qualified = results.filter((r) => !r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
+    const still_running = results.filter((r) => r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
+    return {
+      qualified,
+      still_running,
+      failed,
+      quota_exceeded: quotaExceeded,
+      exhausted,
+      total_unqualified_found: totalUnqualifiedFound,
+      lens_id: lensId,
+      _meta: { region: client.region }
+    };
   }
+};
+
+// ../core/dist/composite/import-and-qualify.js
+function escapeCsv(v) {
+  return escapeCsvCell(v);
 }
-function coerceCell(client, v, path) {
+function coerceCellToString(v) {
   if (v == null)
     return "";
   if (typeof v === "string")
     return v;
   if (typeof v === "number" || typeof v === "boolean")
     return String(v);
-  throw client.makeError("IMPORT_INVALID_CELL_TYPE", `Cell at ${path} is ${Array.isArray(v) ? "an array" : typeof v}, expected string|number|boolean|null`, `Convert the value to a string before passing.`, "POST /imports");
-}
-function prepareDomainsMode(client, inputs) {
-  const validInputs = [];
-  const malformedDomains = [];
-  const byDomain = /* @__PURE__ */ new Map();
-  const byRowId = /* @__PURE__ */ new Map();
-  for (const inp of inputs) {
-    const norm = normalizeDomain(inp?.domain ?? "");
-    if (!norm) {
-      malformedDomains.push(inp?.domain ?? "");
-      continue;
-    }
-    if (byDomain.has(norm))
-      continue;
-    const rowId = randomUUID();
-    const idx = validInputs.length;
-    const name = inp.name?.trim() || norm;
-    validInputs.push({
-      index: idx,
-      rowId,
-      row: { MCP_ROW_ID: rowId, LEAD_NAME: name, LEAD_WEBSITE: norm },
-      domain: norm,
-      outputDomain: norm
-    });
-    byDomain.set(norm, idx);
-    byRowId.set(rowId, idx);
-  }
-  return {
-    mode: "domains",
-    validInputs,
-    malformedDomains,
-    byDomain,
-    byRowId,
-    header: ["MCP_ROW_ID", "LEAD_NAME", "LEAD_WEBSITE"],
-    mappings: {
-      fields: { LEAD_NAME: "LEAD_NAME", LEAD_WEBSITE: "LEAD_WEBSITE" },
-      statuses: {},
-      default_status: null
-    }
-  };
+  return "";
 }
-function prepareRecordsMode(client, records, mappings) {
-  if (!mappings || !mappings.fields || typeof mappings.fields !== "object") {
-    throw client.makeError("IMPORT_MAPPING_REQUIRED", "records[] requires a mappings.fields object", "Pass `mappings: { fields: { CsvColumn: 'LEAD_NAME', ... } }`.", "POST /imports");
-  }
-  const fieldEntries = Object.entries(mappings.fields);
-  if (fieldEntries.length === 0) {
-    throw client.makeError("IMPORT_MAPPING_REQUIRED", "mappings.fields must contain at least one column \u2192 CRM field entry", "Map at least one CSV column to LEAD_NAME or LEAD_WEBSITE.", "POST /imports");
-  }
-  const targets = new Set(fieldEntries.map(([, v]) => v));
-  if (!targets.has("LEAD_NAME") && !targets.has("LEAD_WEBSITE")) {
-    throw client.makeError("IMPORT_MAPPING_NO_RESOLVER", "mappings.fields must include LEAD_NAME or LEAD_WEBSITE", "The wizard needs at least one of those fields to match a lead. Map a CSV column to one of them.", "POST /imports");
-  }
-  for (const [colName] of fieldEntries) {
-    validateColumnName(client, colName, `mappings.fields[${JSON.stringify(colName)}]`);
-    if (RESERVED_COLUMN_RE.test(colName)) {
-      throw client.makeError("IMPORT_RESERVED_COLUMN", `mappings.fields key '${colName}' collides with reserved synthetic column MCP_ROW_ID`, `Rename the column. MCP_ROW_ID (any case) is reserved for tool-internal reconciliation.`, "POST /imports");
-    }
+var DEFAULT_PER_LEAD_BUDGET_MS2 = 9e4;
+var DEFAULT_TOTAL_BUDGET_MS3 = 15 * 6e4;
+var DEFAULT_PER_PHASE_BUDGET_MS2 = 5 * 6e4;
+function pickAdaptiveBudgets(inputSize) {
+  if (inputSize <= 5) {
+    return {
+      per_lead_budget_ms: 6e4,
+      total_budget_ms: 3 * 6e4,
+      per_phase_budget_ms: 9e4,
+      wall_clock_estimate_ms: Math.max(6e4, inputSize * 6e4),
+      strategy: "small"
+    };
   }
-  const headerSet = /* @__PURE__ */ new Set();
-  const coercedRecords = [];
-  records.forEach((rec, i) => {
-    if (rec == null || typeof rec !== "object" || Array.isArray(rec)) {
-      throw client.makeError("IMPORT_INVALID_CELL_TYPE", `records[${i}] must be a plain object`, `Pass each record as { ColumnName: value, ... }.`, "POST /imports");
-    }
-    const out = {};
-    for (const [k, v] of Object.entries(rec)) {
-      validateColumnName(client, k, `records[${i}] key`);
-      if (RESERVED_COLUMN_RE.test(k)) {
-        throw client.makeError("IMPORT_RESERVED_COLUMN", `records[${i}] key '${k}' collides with reserved synthetic column MCP_ROW_ID`, `Rename the column in your records (any case variant of MCP_ROW_ID is reserved).`, "POST /imports");
-      }
-      out[k] = coerceCell(client, v, `records[${i}].${k}`);
-      headerSet.add(k);
-    }
-    coercedRecords.push(out);
-  });
-  for (const [colName] of fieldEntries) {
-    if (!headerSet.has(colName)) {
-      throw client.makeError("IMPORT_MAPPING_KEY_UNKNOWN", `mappings.fields key '${colName}' is not present in any record`, `Add a value for '${colName}' to at least one record, or remove it from mappings.`, "POST /imports");
-    }
+  if (inputSize <= 20) {
+    return {
+      per_lead_budget_ms: 9e4,
+      total_budget_ms: 10 * 6e4,
+      per_phase_budget_ms: 3 * 6e4,
+      wall_clock_estimate_ms: Math.min(10 * 6e4, inputSize * 6e4),
+      strategy: "default"
+    };
   }
-  const userKeys = [...headerSet].sort();
-  const header = ["MCP_ROW_ID", ...userKeys];
-  const websiteCol = fieldEntries.find(([, v]) => v === "LEAD_WEBSITE")?.[0];
-  const validInputs = [];
-  const byDomain = /* @__PURE__ */ new Map();
-  const byRowId = /* @__PURE__ */ new Map();
-  coercedRecords.forEach((row) => {
-    const rowId = randomUUID();
-    const idx = validInputs.length;
-    let normDomain = null;
-    if (websiteCol) {
-      normDomain = normalizeDomain(row[websiteCol] ?? "");
-    }
-    const fullRow = { MCP_ROW_ID: rowId, ...row };
-    validInputs.push({
-      index: idx,
-      rowId,
-      row: fullRow,
-      domain: normDomain,
-      outputDomain: normDomain ?? void 0
-    });
-    byRowId.set(rowId, idx);
-    if (normDomain && !byDomain.has(normDomain))
-      byDomain.set(normDomain, idx);
-  });
   return {
-    mode: "records",
-    validInputs,
-    malformedDomains: [],
-    byDomain,
-    byRowId,
-    header,
-    mappings: {
-      fields: { ...mappings.fields },
-      statuses: mappings.statuses ?? {},
-      default_status: mappings.default_status ?? null
-    }
+    per_lead_budget_ms: 12e4,
+    total_budget_ms: 25 * 6e4,
+    per_phase_budget_ms: 5 * 6e4,
+    // For >20 leads, expect handle-mode return. Estimate is the clip.
+    wall_clock_estimate_ms: 25 * 6e4,
+    strategy: "large"
   };
 }
-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 input in 30s, or split the batch. importId=${importId}.`, `GET /imports/${importId}/records`);
-    }
-    await sleepWithAbort(POLL_INTERVAL_MS, signal);
-  }
+function inputSizeOf(params) {
+  if (Array.isArray(params.domains))
+    return params.domains.length;
+  if (Array.isArray(params.records))
+    return params.records.length;
+  return 0;
 }
-async function runOneChunk(client, chunk, chunkIdx, totalChunks, header, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onImportId) {
-  const csv = synthesizeCsv(header, chunk.map((c) => c.row));
-  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: [] };
-  }
-  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 toNotImportedEntry(n) {
+  const out = { reason: n.reason };
+  if (n.rowId !== void 0)
+    out.rowId = n.rowId;
+  if (n.domain !== void 0)
+    out.domain = n.domain;
+  return out;
 }
-function reconcileOneChunk(prep, chunk, 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 && prep.byRowId.has(rowIdCell)) {
-      inputIdx = prep.byRowId.get(rowIdCell);
-    }
-    if (inputIdx === void 0) {
-      const websiteCell = readCell(rec, "LEAD_WEBSITE");
-      if (websiteCell) {
-        const norm = normalizeDomain(websiteCell);
-        if (norm && prep.byDomain.has(norm)) {
-          inputIdx = prep.byDomain.get(norm);
-        }
-      }
-    }
-    if (inputIdx === void 0 && rec.lead?.website) {
-      const norm = normalizeDomain(rec.lead.website);
-      if (norm && prep.byDomain.has(norm)) {
-        inputIdx = prep.byDomain.get(norm);
-      }
-    }
-    if (inputIdx === void 0)
-      continue;
-    if (seenInputIndex.has(inputIdx)) {
-      if (!matched.has(inputIdx) && !notImported.has(inputIdx)) {
-        const inp2 = prep.validInputs[inputIdx];
-        notImported.set(inputIdx, { domain: inp2.outputDomain, reason: "ambiguous" });
-      }
-      continue;
+function buildFingerprintInput(mappings) {
+  if (!mappings)
+    return { LEAD_NAME: "LEAD_NAME", LEAD_WEBSITE: "LEAD_WEBSITE" };
+  const out = {};
+  const fields = mappings.fields;
+  if (fields && typeof fields === "object") {
+    for (const [k, v] of Object.entries(fields)) {
+      out[k] = String(v);
     }
-    seenInputIndex.add(inputIdx);
-    const inp = prep.validInputs[inputIdx];
-    const matchType = (rec.match_type ?? rec.matchType ?? "").toString();
-    if (rec.lead?.id) {
-      matched.set(inputIdx, {
-        domain: inp.outputDomain,
-        leadId: rec.lead.id,
-        name: rec.lead.name ?? null
-      });
-    } else if (matchType === "NO_MATCH") {
-      const reason = inp.domain && PUBLIC_MAILBOX_DOMAINS.has(inp.domain) ? "no_match" : "uncrawled";
-      notImported.set(inputIdx, { domain: inp.outputDomain, reason });
-    } else {
-      notImported.set(inputIdx, { domain: inp.outputDomain, reason: "internal_error" });
+  }
+  const cf = mappings.custom_fields;
+  if (cf && typeof cf === "object") {
+    for (const [k, v] of Object.entries(cf)) {
+      out[`__cf__${k}`] = String(v);
     }
   }
+  return out;
 }
-var importLeads = {
-  name: "leadbay_import_leads",
-  description: "Import leads into Leadbay's CRM via the file-import wizard. Returns stable Leadbay leadIds for downstream chaining into leadbay_bulk_qualify_leads / leadbay_research_lead.\n\nTWO MODES:\n  A) Domain-list shortcut \u2014 pass `domains: [{domain, name?}]`. The tool builds a 2-column CSV (LEAD_NAME, LEAD_WEBSITE) and imports with the default mapping. Output: { leads: [{domain, leadId, name}], not_imported: [{domain, reason}], importIds, _meta }.\n  B) Custom records + mapping \u2014 pass `records: [{Col1, Col2, ...}]` plus `mappings.fields: {Col1: 'LEAD_NAME', Col2: 'LEAD_WEBSITE', ...}`. The tool synthesizes a CSV from the union of record keys (deterministic order) and POSTs the caller-supplied mapping to the wizard. mappings.fields must include LEAD_NAME or LEAD_WEBSITE (the resolver needs at least one). Output: { leads: [{rowId, domain?, leadId, name}], not_imported: [{rowId, domain?, reason}], importIds, _meta }. `rowId` round-trips your input order.\n\nPass exactly one of `domains` / `records`. Reserved column MCP_ROW_ID (any case) cannot appear in records or mappings \u2014 the tool injects it for stable reconciliation.\n\n\u26A0\uFE0F MUTATES USER STATE. 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\nWhen to use: you have a list of company domains from another system (CRM, analytics, email correspondents) and need stable Leadbay leadIds; or you have CRM-shaped rows with custom columns (sector, location, status, etc.) and want to drive the wizard with explicit field mappings.\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.",
+var importAndQualify = {
+  name: "leadbay_import_and_qualify",
+  description: `Composite: import a list of leads (CSV-shaped records OR a list of domains), then trigger Leadbay's AI qualification (web research + per-question scoring) on every imported leadId, and return both the import outcome and the per-lead qualification answers \u2014 in one call. Honours a total wall-clock budget; when the budget is exhausted before all leads finish qualifying, returns a \`qualify_id\` UUID handle that survives MCP restart and can be passed to leadbay_qualify_status to retrieve the rest of the answers later.
+
+Inputs:
+  - \`domains\`: list of \`{domain, name?}\` (Mode A) \u2014 mutually exclusive with \`records\`.
+  - \`records\`: list of CSV-shaped objects (Mode B), accompanied by \`mappings\`. Use \`mappings.fields\` with     StandardCrmFieldType names or 'CUSTOM.<id>' wire values; or \`mappings.custom_fields\` with field id     or name shorthand. Discover the org's mappable surface via leadbay_list_mappable_fields.
+  - Budgets: \`total_budget_ms\` (default ${DEFAULT_TOTAL_BUDGET_MS3 / 6e4} min) caps the entire wall-clock;     \`per_lead_budget_ms\` (default ${DEFAULT_PER_LEAD_BUDGET_MS2 / 1e3}s) caps each lead's individual qualification poll.
+
+Outputs include \`qualified[]\` (per-lead question answers), \`still_running[]\` (lead ids whose qualification exceeded the budget), \`not_imported[]\` (rows the wizard couldn't match), and \`qualify_id\` (the resumable handle when at least one lead is still running). Idempotent within a 5-min window: re-calling with the same records+mapping returns the same qualify_id (\`reused: true\`). The result has a \`kind\` discriminator (\`'result' | 'preview'\`); preview-mode (\`dry_run: 'preview'\`) returns mapping hints + custom-field candidates instead of importing. Pass \`dry_run: true\` for input-validation only (top-level \`dry_run: true\` appears in the result so the agent can distinguish from all-malformed input).
+
+When to use: the agent has a list of companies (domains, or CSV-shaped rows from the user's CRM) and wants Leadbay's full AI qualification \u2014 qualification answers, web-research signals \u2014 without orchestrating import + bulk_qualify_leads + lead_profile chains by hand.
+When NOT to use: discovery (use leadbay_pull_leads); single-lead deep dive (use leadbay_research_lead); high-cadence or untrusted automation \u2014 this mutates user state by creating CRM-import rows and consumes ai_rescore + web_fetch quota.
+
+\u26A0\uFE0F MUTATES USER STATE. Each call:
+  - creates a CRM-imports row (visible in the web UI)
+  - touches onboarding state
+  - launches up to N\xD7ai_rescore + N\xD7web_fetch quota where N = imported lead count (unless \`skip_already_qualified: true\` (default) excludes already-scored leads)
+
+\u2139\uFE0F Monitor-tab membership: imported leads are NOT auto-promoted to the user's Monitor view. The lens-scoring rule decides \u2014 only leads that score above the lens threshold get \`in_monitor: true\` server-side. Lower-scoring imports stay invisible to the Monitor tab. Tell the user this if they ask 'where did my import go?' \u2014 answer is the CRM-imports list, not Monitor.
+
+\u2139\uFE0F In-lens-but-unscored leads: a lead may be admitted to the active lens (lens GET returns 200) but the lens-scoring job may not materialize for it (qualification never starts). The composite today surfaces hard-rejected leads (404 from lens GET) in \`not_in_lens[]\`, but in-lens-unscored leads currently sit in \`still_running[]\` \u2014 there's no per-lead 'scoring queued vs won't_compute' signal from the backend yet (tracked: leadbay/product#3571). If still_running stays non-empty for a lead more than 5 minutes after a successful import, suggest the user verify the lens covers that lead's profile (e.g., sector match) \u2014 qualify_status's poll won't ever produce answers.
+
+Requires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role; active billing.`,
   write: true,
   version: "0.2.0",
   inputSchema: {
     type: "object",
     properties: {
+      // Pass exactly one of `domains` or `records`. Schema doesn't enforce
+      // XOR (JSON Schema 7 has limited oneOf support); execute() validates.
       domains: {
         type: "array",
         description: "Mode A: list of company domains to map to Leadbay leadIds. Mutually exclusive with `records`.",
@@ -2766,425 +3695,341 @@ var importLeads = {
       },
       records: {
         type: "array",
-        description: "Mode B: arbitrary CSV-shaped rows. Each record is an object whose keys are column names and values are scalar (string/number/boolean/null). Mutually exclusive with `domains`. Must be accompanied by `mappings.fields`. The tool synthesizes a CSV from the union of all record keys.",
+        description: "Mode B: arbitrary CSV-shaped rows. Each record is an object whose keys are column names and values are scalar (string/number/boolean/null). Mutually exclusive with `domains`. Accompany with `mappings` UNLESS using `dry_run: 'preview'` \u2014 preview returns the wizard's mapping suggestions without requiring a mapping up front.",
         items: { type: "object" }
       },
       mappings: {
         type: "object",
-        description: "Mode B: how each CSV column maps to Leadbay's CRM field schema. Required when `records` is supplied; ignored otherwise.",
+        description: "How each CSV column maps to Leadbay's CRM field schema. Required for records-mode WITHOUT `dry_run: 'preview'`; ignored otherwise. The `fields` sub-property is REQUIRED only when at least one column maps to a StandardCrmFieldType target; pure custom-field mappings can be supplied via `custom_fields` shorthand alone.",
         properties: {
           fields: {
             type: "object",
-            description: "Object whose keys are CSV column names (matching keys in `records`) and whose values are Leadbay CRM field types (LEAD_NAME, LEAD_WEBSITE, LEAD_STATUS, LEAD_LOCATION, LEAD_SECTOR, LEAD_SIZE, CRM_ID, LEADBAY_ID, EMAIL, DEAL_CRM_ID, CONTACT_TITLE, LEAD_STATUS_DATE). At least one entry must target LEAD_NAME or LEAD_WEBSITE \u2014 the wizard needs that to find leads."
+            description: "Object whose keys are CSV column names and whose values are either StandardCrmFieldType (LEAD_NAME, LEAD_WEBSITE, ..., CONTACT_TITLE) or 'CUSTOM.<id>'. Discover via leadbay_list_mappable_fields. At least one entry must target LEAD_NAME or LEAD_WEBSITE."
           },
-          statuses: {
+          custom_fields: {
             type: "object",
-            description: "Optional status string mapping (rarely needed). Defaults to {}."
+            description: "Ergonomic shorthand: `{CsvColumn: <number-id>}` or `{CsvColumn: '<field-name>'}` for custom-field mappings. Resolved against /crm/custom_fields catalog."
           },
-          default_status: {
-            type: ["string", "null"],
-            description: "Optional default status. Defaults to null."
-          }
-        },
-        required: ["fields"]
-      },
-      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 input format / wizard reachability without polluting the CRM."
+          statuses: { type: "object", description: "Optional status string mapping." },
+          default_status: { type: ["string", "null"], description: "Optional default status." }
+        }
       },
-      per_phase_budget_ms: {
+      per_lead_budget_ms: {
         type: "number",
-        description: `Single poll-loop cap (default ${DEFAULT_PER_PHASE_BUDGET_MS}ms).`
+        description: `Polling budget per lead in ms (default ${DEFAULT_PER_LEAD_BUDGET_MS2}).`
       },
       total_budget_ms: {
         type: "number",
-        description: `Overall cap across all phases (default ${DEFAULT_TOTAL_BUDGET_MS2}ms).`
-      }
-    }
-    // Neither field is "required" at the schema level; xor + presence is
-    // enforced in execute() so we can produce specific error codes.
-  },
-  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;
-    const hasDomains = Array.isArray(params.domains) && params.domains.length > 0;
-    const hasRecords = Array.isArray(params.records) && params.records.length > 0;
-    if (hasDomains && hasRecords) {
-      throw client.makeError("IMPORT_INPUT_CONFLICT", "Pass exactly one of `domains` or `records`, not both", "Use `domains` for the simple shortcut, or `records`+`mappings` for arbitrary CSV input.", "POST /imports");
-    }
-    if (!hasDomains && !hasRecords) {
-      throw client.makeError("IMPORT_EMPTY_INPUT", "domains[] or records[] must contain at least one entry", "Pass at least one entry. See the tool description for the two input modes.", "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 prep = hasDomains ? prepareDomainsMode(client, params.domains) : prepareRecordsMode(client, params.records, params.mappings);
-    if (prep.validInputs.length === 0) {
-      const not_imported2 = prep.malformedDomains.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(prep.validInputs);
-    ctx?.logger?.info?.(`import-leads(${prep.mode}): ${prep.validInputs.length} rows \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, prep.header, prep.mappings, dryRun, perPhaseBudget, totalDeadline, ctx, signal, recordImportId);
-        if (!dryRun) {
-          reconcileOneChunk(prep, out, matched, notImported);
-        }
-      }
-    } 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;
-      }
-    }
-    const leads = [];
-    const not_imported = [];
-    if (dryRun) {
-      for (const inp of prep.validInputs) {
-        if (prep.mode === "domains") {
-          not_imported.push({ domain: inp.outputDomain, reason: "dry_run" });
-        } else {
-          const entry = { rowId: inp.rowId, reason: "dry_run" };
-          if (inp.outputDomain)
-            entry.domain = inp.outputDomain;
-          not_imported.push(entry);
-        }
-      }
-    } else {
-      for (const inp of prep.validInputs) {
-        const m = matched.get(inp.index);
-        if (m) {
-          if (prep.mode === "domains") {
-            leads.push({
-              domain: inp.outputDomain,
-              leadId: m.leadId,
-              name: m.name
-            });
-          } else {
-            const e = {
-              rowId: inp.rowId,
-              leadId: m.leadId,
-              name: m.name
-            };
-            if (m.domain ?? inp.outputDomain)
-              e.domain = m.domain ?? inp.outputDomain;
-            leads.push(e);
-          }
-          continue;
-        }
-        const ni = notImported.get(inp.index);
-        if (ni) {
-          if (prep.mode === "domains") {
-            not_imported.push({ domain: inp.outputDomain, reason: ni.reason });
-          } else {
-            const e = { rowId: inp.rowId, reason: ni.reason };
-            if (ni.domain ?? inp.outputDomain)
-              e.domain = ni.domain ?? inp.outputDomain;
-            not_imported.push(e);
-          }
-          continue;
-        }
-        if (prep.mode === "domains") {
-          not_imported.push({ domain: inp.outputDomain, reason: "internal_error" });
-        } else {
-          const e = { rowId: inp.rowId, reason: "internal_error" };
-          if (inp.outputDomain)
-            e.domain = inp.outputDomain;
-          not_imported.push(e);
-        }
-      }
-    }
-    for (const m of prep.malformedDomains) {
-      not_imported.push({ domain: m, reason: "malformed" });
-    }
-    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. 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: {
-      titles: {
-        type: "array",
-        items: { type: "string" },
-        description: "Job titles to enrich. Omit to discover what's available without launching."
-      },
-      leadIds: {
-        type: "array",
-        items: { type: "string" },
-        description: "Lead UUIDs to enrich. Omit to use the top page of the active lens's wishlist."
+        description: `Total wall-clock budget across import + qualify in ms (default ${DEFAULT_TOTAL_BUDGET_MS3}). When exhausted, the response returns qualify_id for resume via leadbay_qualify_status.`
       },
-      lensId: {
+      per_phase_budget_ms: {
         type: "number",
-        description: "Lens id (escape hatch \u2014 defaults to active)"
+        description: `Per-phase budget for the import wizard (default ${DEFAULT_PER_PHASE_BUDGET_MS2}); mirrors leadbay_import_leads.`
       },
-      email: { type: "boolean", description: "Enrich emails (default true)" },
-      phone: { type: "boolean", description: "Enrich phone numbers (default false)" },
-      candidateCount: {
+      lensId: {
         type: "number",
-        description: `When leadIds is omitted, how many top-of-wishlist leads to use (default ${DEFAULT_CANDIDATE_COUNT})`
+        description: "Lens id (escape hatch \u2014 defaults to active)."
       },
       dry_run: {
+        description: "Optional. `true` runs preprocess only (no commit, no qualify). `'preview'` runs preprocess and returns the wizard's per-column AI mapping hints + sample rows + custom-field candidates from the org catalog so the agent can choose a mapping. Default: false (full flow)."
+      },
+      skip_already_qualified: {
         type: "boolean",
-        description: "If true, don't launch \u2014 only preview."
+        description: "When true (default), skips web_fetch launch on leads whose ai_agent_lead_score is already non-null. Saves quota. Set false to force fresh re-qualification."
       }
     }
   },
   execute: async (client, params, ctx) => {
-    const email = params.email ?? true;
-    const phone = params.phone ?? false;
-    if (!email && !phone) {
+    const signal = ctx?.signal;
+    let chosenBudgets;
+    if (params.dry_run !== "preview" && params.per_lead_budget_ms === void 0 && params.total_budget_ms === void 0 && params.per_phase_budget_ms === void 0) {
+      chosenBudgets = pickAdaptiveBudgets(inputSizeOf(params));
+    }
+    const perLeadBudget = params.per_lead_budget_ms ?? chosenBudgets?.per_lead_budget_ms ?? DEFAULT_PER_LEAD_BUDGET_MS2;
+    const totalBudget = params.total_budget_ms ?? chosenBudgets?.total_budget_ms ?? DEFAULT_TOTAL_BUDGET_MS3;
+    const perPhaseBudget = params.per_phase_budget_ms ?? chosenBudgets?.per_phase_budget_ms ?? DEFAULT_PER_PHASE_BUDGET_MS2;
+    const totalDeadline = Date.now() + totalBudget;
+    const skipAlreadyQualified = params.skip_already_qualified ?? true;
+    if (params.dry_run === "preview") {
+      return await runPreview(client, params, ctx, perPhaseBudget, totalBudget);
+    }
+    if (!ctx?.bulkTracker) {
+      throw client.makeError("BULK_TRACKER_UNAVAILABLE", "No BulkTracker configured on this MCP instance", "leadbay_import_and_qualify needs a BulkTracker (qualify_id persistence). Upgrade to @leadbay/mcp \u22650.5.0 or set LEADBAY_BULK_STORE_ALLOW_MEMORY=1.", "");
+    }
+    const importResult = await importLeads.execute(client, {
+      domains: params.domains,
+      records: params.records,
+      mappings: params.mappings,
+      per_phase_budget_ms: perPhaseBudget,
+      total_budget_ms: totalBudget,
+      ...params.dry_run === true ? { dry_run: true } : {}
+    }, ctx);
+    if (importResult.cancelled) {
       return {
-        error: true,
-        code: "BAD_INPUT",
-        message: "Either email or phone must be true",
-        hint: "Set email:true (most common) or phone:true"
+        kind: "result",
+        ...params.dry_run === true ? { dry_run: true } : {},
+        ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
+        qualify_id: null,
+        import_ids: importResult.importIds,
+        imported: [],
+        not_imported: importResult.not_imported.map(toNotImportedEntry),
+        qualified: [],
+        still_running: [],
+        failed: [],
+        quota_exceeded: false,
+        skipped_already_qualified: [],
+        not_in_lens: [],
+        cancelled: true,
+        region: client.region,
+        _meta: client.lastMeta ?? {
+          region: client.region,
+          endpoint: "POST /imports",
+          latency_ms: null,
+          retry_after: null
+        }
       };
     }
-    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 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);
-    }
-    if (leadIds.length === 0) {
+    const imported = importResult.leads.map((l) => {
+      const out = {
+        leadId: l.leadId,
+        name: l.name
+      };
+      if (l.domain)
+        out.domain = l.domain;
+      if (l.rowId)
+        out.rowId = l.rowId;
+      return out;
+    });
+    const not_imported = importResult.not_imported.map(toNotImportedEntry);
+    if (imported.length === 0) {
       return {
-        error: true,
-        code: "NO_CANDIDATES",
-        message: "No candidate leads",
-        hint: "Pass leadIds explicitly or wait for the wishlist to compute"
+        kind: "result",
+        ...params.dry_run === true ? { dry_run: true } : {},
+        ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
+        qualify_id: null,
+        import_ids: importResult.importIds,
+        imported,
+        not_imported,
+        qualified: [],
+        still_running: [],
+        failed: [],
+        quota_exceeded: false,
+        skipped_already_qualified: [],
+        not_in_lens: [],
+        region: client.region,
+        _meta: client.lastMeta ?? {
+          region: client.region,
+          endpoint: "POST /imports",
+          latency_ms: null,
+          retry_after: null
+        }
       };
     }
-    await client.acquireSelectionLock();
-    try {
-      const qs = leadIds.map((id) => `leadIds=${encodeURIComponent(id)}`).join("&");
-      await client.requestVoid("POST", `/leads/selection/select?${qs}`);
+    const lensId = params.lensId ?? await client.resolveDefaultLens();
+    const leadIdsFromImported = imported.map((l) => l.leadId);
+    const leadIdSet = new Set(leadIdsFromImported);
+    const leadsResults = await Promise.allSettled(importResult.importIds.map((importId) => client.request("GET", `/imports/${importId}/leads`)));
+    leadsResults.forEach((r, i) => {
+      if (r.status === "fulfilled" && Array.isArray(r.value?.lead_ids)) {
+        for (const id of r.value.lead_ids)
+          leadIdSet.add(id);
+      } else if (r.status === "rejected") {
+        const err = r.reason;
+        ctx?.logger?.warn?.(`import_and_qualify: /imports/${importResult.importIds[i]}/leads unavailable (${err?.code ?? err?.message ?? "unknown"}) \u2014 using per-record reconciliation`);
+      }
+    });
+    const leadIds = [...leadIdSet];
+    const mappingFp = fingerprintMapping(
+      // For domains-mode the mapping is the canonical {LEAD_NAME, LEAD_WEBSITE}.
+      // For records-mode include BOTH `fields` and `custom_fields` shorthand
+      // so two calls with the same `fields` but different custom-field
+      // targets do NOT collide on the same qualify_id.
+      buildFingerprintInput(params.mappings)
+    );
+    const reservation = await ctx.bulkTracker.findOrCreatePendingQualify({
+      lead_ids: leadIds,
+      import_ids: importResult.importIds,
+      lens_id: lensId,
+      mapping_fingerprint: mappingFp,
+      per_lead_budget_ms: perLeadBudget,
+      total_budget_ms: totalBudget
+    });
+    if (reservation.reused) {
+      ctx?.logger?.info?.(`import_and_qualify: reusing qualify_id=${reservation.record.bulk_id} (seconds_since_original=${reservation.seconds_since_original})`);
+    }
+    let launchMarked = false;
+    for (const attempt of [1, 2]) {
       try {
-        const availableTitles = await client.request("GET", "/leads/selection/enrichment/job_titles");
-        if (!params.titles || params.titles.length === 0) {
-          let suggestions = [];
-          let autoIncluded = [];
-          let previouslyEnriched = [];
-          let enrichableContacts = 0;
-          try {
-            const prev = await client.request("POST", "/leads/selection/enrichment/preview", { titles: [] });
-            suggestions = prev.title_suggestions ?? [];
-            autoIncluded = prev.auto_included_titles ?? [];
-            previouslyEnriched = prev.previously_enriched_titles ?? [];
-            enrichableContacts = prev.enrichable_contacts;
-          } catch (e) {
-            ctx?.logger?.warn?.(`enrich_titles: 0-titles preview failed: ${e?.message}`);
-          }
-          return {
-            mode: "discover",
-            available_titles: availableTitles,
-            recommendations: suggestions,
-            auto_included: autoIncluded,
-            previously_enriched: previouslyEnriched,
-            enrichable_contacts: enrichableContacts,
-            selected_lead_count: leadIds.length,
-            next_action: "Pick titles to enrich and call leadbay_enrich_titles again with titles=[...]"
-          };
-        }
-        let preview;
-        try {
-          preview = await client.request("POST", "/leads/selection/enrichment/preview", { titles: params.titles });
-        } catch (err) {
-          if (err?.code === "QUOTA_EXCEEDED") {
-            return {
-              status: "quota_exceeded",
-              message: "Quota exceeded on preview",
-              retry_after_seconds: err?._meta?.retry_after ?? null
-            };
-          }
-          throw err;
-        }
-        if (preview.enrichable_contacts === 0) {
-          return {
-            mode: "preview_only",
-            preview,
-            launched: false,
-            message: "No enrichable contacts for the chosen titles. Try other titles from available_titles or recommendations.",
-            available_titles: availableTitles
-          };
-        }
-        if (params.dry_run) {
-          return {
-            mode: "dry_run",
-            preview,
-            launched: false,
-            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",
-              preview,
-              message: "Quota exceeded on launch",
-              retry_after_seconds: err?._meta?.retry_after ?? null
-            };
-          }
-          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,
-          launched: true,
-          titles: params.titles,
-          email,
-          phone,
-          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 {
-          await client.requestVoid("POST", "/leads/selection/clear");
-        } catch (e) {
-          ctx?.logger?.warn?.(`enrich_titles: selection.clear failed: ${e?.message ?? e?.code}`);
-        }
+        await ctx.bulkTracker.markLaunched(reservation.record.bulk_id);
+        launchMarked = true;
+        break;
+      } catch (err) {
+        ctx?.logger?.warn?.(`import_and_qualify: markLaunched attempt ${attempt} failed: ${err?.message ?? err}`);
       }
-    } finally {
-      client.releaseSelectionLock();
     }
+    if (!launchMarked) {
+      ctx?.logger?.warn?.(`import_and_qualify: markLaunched failed twice \u2014 qualify_status may BULK_PENDING-trap immediate retrieval; agent should poll, not relaunch`);
+    }
+    let questionOrder = void 0;
+    try {
+      const taste = await client.resolveTasteProfile();
+      questionOrder = buildQuestionOrder(taste.qualificationQuestions ?? []);
+    } catch (err) {
+      ctx?.logger?.warn?.(`qualify: question order unavailable (${err?.code ?? err?.message ?? "unknown"}) \u2014 falling back to alphabetical`);
+    }
+    const fanOut = await fanOutWebFetchAndPoll(client, leadIds, {
+      perLeadBudgetMs: perLeadBudget,
+      totalDeadlineMs: totalDeadline,
+      signal,
+      ctx,
+      skipAlreadyQualifiedLensId: lensId,
+      skipAlreadyQualifiedLaunch: skipAlreadyQualified,
+      ...questionOrder ? { questionOrder } : {}
+    });
+    const qualified = fanOut.results.filter((r) => !r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
+    const notInLensSet = new Set(fanOut.not_in_lens);
+    const stillRunningIds = new Set([
+      ...fanOut.results.filter((r) => r._stillRunning).map((r) => r.lead_id),
+      ...fanOut.not_launched
+    ].filter((id) => !notInLensSet.has(id)));
+    const still_running = [...stillRunningIds].map((lead_id) => ({ lead_id }));
+    const budgetExhausted = Date.now() >= totalDeadline && still_running.length > 0;
+    const quotaBlocked = fanOut.quota_exceeded && still_running.length > 0 && !budgetExhausted;
+    const skipped_already_qualified = skipAlreadyQualified && fanOut.skipped_already_qualified ? [...fanOut.skipped_already_qualified] : [];
+    return {
+      kind: "result",
+      ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
+      qualify_id: reservation.record.bulk_id,
+      import_ids: importResult.importIds,
+      imported,
+      not_imported,
+      qualified,
+      still_running,
+      failed: fanOut.failed,
+      quota_exceeded: fanOut.quota_exceeded,
+      skipped_already_qualified,
+      not_in_lens: fanOut.not_in_lens,
+      ...reservation.reused ? {
+        reused: true,
+        seconds_since_original: reservation.seconds_since_original
+      } : {},
+      ...fanOut.cancelled ? { cancelled: true } : {},
+      ...budgetExhausted ? { budget_exhausted: true } : {},
+      ...quotaBlocked ? { quota_blocked: true } : {},
+      region: client.region,
+      _meta: client.lastMeta ?? {
+        region: client.region,
+        endpoint: "POST /imports \u2192 /web_fetch",
+        latency_ms: null,
+        retry_after: null
+      }
+    };
   }
 };
+async function runPreview(client, params, ctx, perPhaseBudget, _totalBudget) {
+  const me = await client.resolveMe();
+  if (!me.admin) {
+    throw client.makeError("IMPORT_ADMIN_REQUIRED", "Preview mode 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 PREVIEW_SAMPLE_CAP2 = 50;
+  let csv;
+  if (Array.isArray(params.domains) && params.domains.length > 0) {
+    const sample = params.domains.slice(0, PREVIEW_SAMPLE_CAP2);
+    const lines = ["LEAD_NAME,LEAD_WEBSITE"];
+    for (const d of sample) {
+      const dom = (d.domain ?? "").replace(/[",\n\r]/g, " ").trim();
+      const name = (d.name ?? dom).replace(/[",\n\r]/g, " ").trim();
+      lines.push(`${escapeCsv(name)},${escapeCsv(dom)}`);
+    }
+    csv = lines.join("\n") + "\n";
+  } else if (Array.isArray(params.records) && params.records.length > 0) {
+    const sample = params.records.slice(0, PREVIEW_SAMPLE_CAP2);
+    const headerSet = /* @__PURE__ */ new Set();
+    for (const r of sample)
+      for (const k of Object.keys(r))
+        headerSet.add(k);
+    const header = [...headerSet];
+    const lines = [header.map(escapeCsv).join(",")];
+    for (const r of sample) {
+      lines.push(header.map((c) => escapeCsv(coerceCellToString(r[c]))).join(","));
+    }
+    csv = lines.join("\n") + "\n";
+  } else {
+    throw client.makeError("IMPORT_EMPTY_INPUT", "Preview mode requires `domains` or `records`", "Pass at least one row to preview against.", "POST /imports");
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const fileName = `mcp-preview-${ts}.csv`;
+  ctx?.logger?.info?.(`import_and_qualify(preview): uploading sample (${csv.length}B) for hints`);
+  const upload = await client.requestRawBinary("POST", `/imports?file_name=${encodeURIComponent(fileName)}`, "text/csv", csv);
+  const importId = upload.id;
+  const signal = ctx?.signal;
+  const deadline = Date.now() + perPhaseBudget;
+  let fileImport = null;
+  while (Date.now() < deadline) {
+    if (signal?.aborted) {
+      throw Object.assign(new Error("aborted"), { name: "AbortError" });
+    }
+    const r = await client.request("GET", `/imports/${importId}`);
+    if (r.pre_processing?.finished) {
+      fileImport = r;
+      break;
+    }
+    await new Promise((res) => {
+      const t = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        res();
+      }, 2e3);
+      const onAbort = () => {
+        clearTimeout(t);
+        signal?.removeEventListener("abort", onAbort);
+        res();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  if (signal?.aborted) {
+    throw Object.assign(new Error("aborted"), { name: "AbortError" });
+  }
+  if (!fileImport) {
+    throw client.makeError("IMPORT_BUDGET_EXHAUSTED", `Preview preprocess did not finish within ${perPhaseBudget}ms`, "Increase per_phase_budget_ms or shrink the input. The wizard row will eventually be cleaned up.", `GET /imports/${importId}`);
+  }
+  if (fileImport.pre_processing?.error) {
+    throw client.makeError("IMPORT_PREPROCESS_FAILED", `Preview preprocess failed: ${fileImport.pre_processing.error}`, "Inspect the input rows for encoding / shape issues.", `GET /imports/${importId}`);
+  }
+  const notes = [];
+  if (Array.isArray(params.domains)) {
+    notes.push("domains-mode: hints reflect the synthesized LEAD_NAME/LEAD_WEBSITE columns only.");
+  }
+  let catalog = [];
+  try {
+    catalog = await client.request("GET", "/crm/custom_fields") ?? [];
+  } catch (err) {
+    notes.push(`custom-field catalog unavailable: ${err?.code ?? err?.message ?? "unknown"}`);
+  }
+  const { mapping_hints, custom_field_candidates, sample_rows } = extractHintsAndCandidates(fileImport, catalog);
+  return {
+    kind: "preview",
+    mapping_hints,
+    custom_field_candidates,
+    sample_rows,
+    notes,
+    import_id: importId,
+    region: client.region,
+    _meta: client.lastMeta ?? {
+      region: client.region,
+      endpoint: `GET /imports/${importId}`,
+      latency_ms: null,
+      retry_after: null
+    }
+  };
+}
 
 // ../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";
+import { createHash as createHash2, 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;
@@ -3199,7 +4044,17 @@ function computeIdempotencyKey(args) {
     args.phone ? "p1" : "p0",
     `l${args.lens_id}`
   ];
-  return createHash("sha256").update(parts.join("|")).digest("hex");
+  return createHash2("sha256").update(parts.join("|")).digest("hex");
+}
+function computeQualifyIdempotencyKey(args) {
+  const parts = [
+    "qualify",
+    [...args.lead_ids].sort().join(","),
+    [...args.import_ids].sort().join(","),
+    `l${args.lens_id}`,
+    args.mapping_fingerprint
+  ];
+  return createHash2("sha256").update(parts.join("|")).digest("hex");
 }
 function normalizeLaunchInputs(args) {
   return {
@@ -3267,275 +4122,669 @@ var LocalBulkStore = class {
   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.`);
+  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 (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");
+    const kind = r.kind ?? "enrich";
+    if (kind === "qualify") {
+      if (!Array.isArray(r.import_ids) || !r.import_ids.every((x) => typeof x === "string"))
+        throw new Error("invalid import_ids");
+      if (typeof r.lens_id !== "number")
+        throw new Error("invalid lens_id");
+      const out = {
+        kind: "qualify",
+        bulk_id: r.bulk_id,
+        launched_at: r.launched_at,
+        lead_ids: r.lead_ids,
+        import_ids: r.import_ids,
+        lens_id: r.lens_id,
+        status: r.status,
+        idempotency_key: r.idempotency_key,
+        durability: this.backend
+      };
+      if (typeof r.per_lead_budget_ms === "number")
+        out.per_lead_budget_ms = r.per_lead_budget_ms;
+      if (typeof r.total_budget_ms === "number")
+        out.total_budget_ms = r.total_budget_ms;
+      return out;
+    }
+    if (kind === "enrich") {
+      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");
+      return {
+        kind: "enrich",
+        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
+      };
+    }
+    throw new Error(`unknown kind: ${String(kind)}`);
+  }
+  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.kind === "enrich" && 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 = {
+        kind: "enrich",
+        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 kind=enrich 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 findOrCreatePendingQualify(args) {
+    const lead_ids = [...new Set(args.lead_ids)].sort();
+    const import_ids = [...new Set(args.import_ids)].sort();
+    const idempotency_key = computeQualifyIdempotencyKey({
+      lead_ids,
+      import_ids,
+      lens_id: args.lens_id,
+      mapping_fingerprint: args.mapping_fingerprint
+    });
+    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.kind === "qualify" && r.idempotency_key === idempotency_key && r.status !== "failed" && nowMs - Date.parse(r.launched_at) < window);
+      if (existing) {
+        this.logger?.info?.(`bulk.reused kind=qualify 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 = {
+        kind: "qualify",
+        bulk_id: randomUUID2(),
+        launched_at: new Date(nowMs).toISOString(),
+        lead_ids,
+        import_ids,
+        lens_id: args.lens_id,
+        status: "pending",
+        idempotency_key,
+        durability: this.backend
+      };
+      if (args.per_lead_budget_ms !== void 0)
+        record.per_lead_budget_ms = args.per_lead_budget_ms;
+      if (args.total_budget_ms !== void 0)
+        record.total_budget_ms = args.total_budget_ms;
+      all.push(record);
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.registered kind=qualify bulk_id=${record.bulk_id} lens_id=${record.lens_id} lead_count=${record.lead_ids.length} import_count=${record.import_ids.length} durability=${record.durability}`);
+      return { record, reused: false };
+    });
+  }
+  async getQualify(bulk_id) {
+    const r = await this.get(bulk_id);
+    return r && r.kind === "qualify" ? r : void 0;
+  }
+  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 });
   }
-  async ensureInitialized() {
-    if (this.initialized || this.backend !== "file") {
-      this.initialized = true;
-      return;
+}
+
+// ../core/dist/composite/qualify-status.js
+var qualifyStatus = {
+  name: "leadbay_qualify_status",
+  description: "Retrieve the current state of an import_and_qualify launch by `qualify_id`. Returns the same `qualified[]` / `still_running[]` shape as the original composite, refreshed against the backend at call time. The handle is persisted to ~/.leadbay/bulks.json with a 30-day TTL and survives MCP restart.\n\nWhen to use: after leadbay_import_and_qualify returned a qualify_id with non-empty `still_running[]`, call this tool a few minutes later (or hours) to retrieve the now-completed qualifications without re-running the import or re-spending qualify quota.\nWhen NOT to use: as a substitute for leadbay_research_lead \u2014 that's a deeper per-lead profile and includes contacts. This tool is purely the qualification answers + signals_count.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      qualify_id: {
+        type: "string",
+        description: "UUIDv4 returned by leadbay_import_and_qualify when at least one lead was still running."
+      }
+    },
+    required: ["qualify_id"]
+  },
+  execute: async (client, params, ctx) => {
+    if (!isValidBulkId(params.qualify_id)) {
+      throw client.makeError("BULK_INVALID_ID", "qualify_id is not a valid UUIDv4", "Pass the qualify_id returned by leadbay_import_and_qualify verbatim.", "");
     }
-    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.`);
+    if (!ctx?.bulkTracker) {
+      throw client.makeError("BULK_TRACKER_UNAVAILABLE", "No BulkTracker configured on this MCP instance", "leadbay_qualify_status needs a BulkTracker. Upgrade to @leadbay/mcp \u22650.5.0 or set LEADBAY_BULK_STORE_ALLOW_MEMORY=1.", "");
+    }
+    const record = await ctx.bulkTracker.getQualify(params.qualify_id);
+    if (!record) {
+      const any = await ctx.bulkTracker.get(params.qualify_id);
+      if (any && any.kind !== "qualify") {
+        throw client.makeError("BULK_WRONG_KIND", "This bulk_id was created by leadbay_enrich_titles, not leadbay_import_and_qualify", "Call leadbay_bulk_enrich_status with this id instead.", "");
       }
-    } catch (err) {
-      if (err?.code !== "ENOENT")
-        throw err;
+      throw client.makeError("BULK_NOT_FOUND", "No qualify record for that qualify_id", "It may have expired (30-day TTL) or the MCP process was restarted without persistence. Re-launch via leadbay_import_and_qualify.", "");
     }
-    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;
+    if (record.status === "pending") {
+      throw client.makeError("BULK_PENDING", "Qualify record is in 'pending' state \u2014 the launch may be in flight or crashed before launch ack", "Retry leadbay_qualify_status in a few seconds. If it persists >60s, relaunch via leadbay_import_and_qualify.", "");
     }
-    let parsed;
+    if (record.status === "failed") {
+      throw client.makeError("BULK_LAUNCH_FAILED", "The original import_and_qualify launch failed; no qualifications were ordered", "Call leadbay_import_and_qualify again \u2014 the failed record won't block a fresh launch.", "");
+    }
+    let questionOrder = void 0;
     try {
-      parsed = JSON.parse(raw);
-    } catch (err) {
-      this.logger?.warn?.(`bulk.record_dropped file_parse_failed ${err?.message ?? err}`);
-      return [];
+      const taste = await client.resolveTasteProfile();
+      questionOrder = buildQuestionOrder(taste.qualificationQuestions ?? []);
+    } catch {
     }
-    if (!Array.isArray(parsed)) {
-      this.logger?.warn?.("bulk.record_dropped file_not_array");
-      return [];
+    let notInLensSet = /* @__PURE__ */ new Set();
+    try {
+      const pre = await prequalifiedLeads(client, record.lead_ids, record.lens_id, ctx);
+      notInLensSet = pre.not_in_lens;
+    } catch {
     }
-    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}`);
+    const fresh = await refreshLeadStates(client, record.lead_ids, questionOrder);
+    const failed = [];
+    const qualified = [];
+    const still_running = [];
+    for (const r of fresh) {
+      if (r._failedCode) {
+        failed.push({ lead_id: r.lead_id, error: r._failedCode });
+        continue;
+      }
+      if (notInLensSet.has(r.lead_id) && r._stillRunning) {
+        continue;
+      }
+      if (r._stillRunning) {
+        still_running.push({ lead_id: r.lead_id });
+        continue;
       }
+      const { _stillRunning, _failedCode, ...rest } = r;
+      qualified.push(rest);
     }
-    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
+    const out = {
+      qualify_id: record.bulk_id,
+      launched_at: record.launched_at,
+      status: record.status,
+      import_ids: record.import_ids,
+      lens_id: record.lens_id,
+      lead_ids: record.lead_ids,
+      qualified,
+      still_running,
+      failed,
+      not_in_lens: [...notInLensSet],
+      region: client.region,
+      _meta: client.lastMeta ?? {
+        region: client.region,
+        endpoint: "GET /leads/<id>/web_fetch + /ai_agent_responses",
+        latency_ms: null,
+        retry_after: null
+      }
     };
+    if (record.per_lead_budget_ms !== void 0)
+      out.per_lead_budget_ms = record.per_lead_budget_ms;
+    if (record.total_budget_ms !== void 0)
+      out.total_budget_ms = record.total_budget_ms;
+    return out;
   }
-  async writeAll(records) {
-    if (this.backend === "memory") {
-      this.memory = records.map((r) => ({ ...r, durability: "memory" }));
-      return;
+};
+
+// ../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. 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: {
+      titles: {
+        type: "array",
+        items: { type: "string" },
+        description: "Job titles to enrich. Omit to discover what's available without launching."
+      },
+      leadIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs to enrich. Omit to use the top page of the active lens's wishlist."
+      },
+      lensId: {
+        type: "number",
+        description: "Lens id (escape hatch \u2014 defaults to active)"
+      },
+      email: { type: "boolean", description: "Enrich emails (default true)" },
+      phone: { type: "boolean", description: "Enrich phone numbers (default false)" },
+      candidateCount: {
+        type: "number",
+        description: `When leadIds is omitted, how many top-of-wishlist leads to use (default ${DEFAULT_CANDIDATE_COUNT})`
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, don't launch \u2014 only preview."
+      }
     }
-    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();
+  },
+  execute: async (client, params, ctx) => {
+    const email = params.email ?? true;
+    const phone = params.phone ?? false;
+    if (!email && !phone) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: "Either email or phone must be true",
+        hint: "Set email:true (most common) or phone:true"
+      };
     }
-    if (platform() === "win32") {
+    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 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);
+    }
+    if (leadIds.length === 0) {
+      return {
+        error: true,
+        code: "NO_CANDIDATES",
+        message: "No candidate leads",
+        hint: "Pass leadIds explicitly or wait for the wishlist to compute"
+      };
+    }
+    await client.acquireSelectionLock();
+    try {
+      const qs = leadIds.map((id) => `leadIds=${encodeURIComponent(id)}`).join("&");
+      await client.requestVoid("POST", `/leads/selection/select?${qs}`);
       try {
-        await unlink(this.path);
-      } catch (err) {
-        if (err?.code !== "ENOENT")
+        const availableTitles = await client.request("GET", "/leads/selection/enrichment/job_titles");
+        if (!params.titles || params.titles.length === 0) {
+          let suggestions = [];
+          let autoIncluded = [];
+          let previouslyEnriched = [];
+          let enrichableContacts = 0;
+          try {
+            const prev = await client.request("POST", "/leads/selection/enrichment/preview", { titles: [] });
+            suggestions = prev.title_suggestions ?? [];
+            autoIncluded = prev.auto_included_titles ?? [];
+            previouslyEnriched = prev.previously_enriched_titles ?? [];
+            enrichableContacts = prev.enrichable_contacts;
+          } catch (e) {
+            ctx?.logger?.warn?.(`enrich_titles: 0-titles preview failed: ${e?.message}`);
+          }
+          return {
+            mode: "discover",
+            available_titles: availableTitles,
+            recommendations: suggestions,
+            auto_included: autoIncluded,
+            previously_enriched: previouslyEnriched,
+            enrichable_contacts: enrichableContacts,
+            selected_lead_count: leadIds.length,
+            next_action: "Pick titles to enrich and call leadbay_enrich_titles again with titles=[...]"
+          };
+        }
+        let preview;
+        try {
+          preview = await client.request("POST", "/leads/selection/enrichment/preview", { titles: params.titles });
+        } catch (err) {
+          if (err?.code === "QUOTA_EXCEEDED") {
+            return {
+              status: "quota_exceeded",
+              message: "Quota exceeded on preview",
+              retry_after_seconds: err?._meta?.retry_after ?? null
+            };
+          }
+          throw err;
+        }
+        if (preview.enrichable_contacts === 0) {
+          return {
+            mode: "preview_only",
+            preview,
+            launched: false,
+            message: "No enrichable contacts for the chosen titles. Try other titles from available_titles or recommendations.",
+            available_titles: availableTitles
+          };
+        }
+        if (params.dry_run) {
+          return {
+            mode: "dry_run",
+            preview,
+            launched: false,
+            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",
+              preview,
+              message: "Quota exceeded on launch",
+              retry_after_seconds: err?._meta?.retry_after ?? null
+            };
+          }
           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)}`);
+        }
+        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 {
-          record: existing,
-          reused: true,
-          seconds_since_original: Math.round((nowMs - Date.parse(existing.launched_at)) / 1e3)
+          mode: "launched",
+          preview,
+          launched: true,
+          titles: params.titles,
+          email,
+          phone,
+          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 {
+          await client.requestVoid("POST", "/leads/selection/clear");
+        } catch (e) {
+          ctx?.logger?.warn?.(`enrich_titles: selection.clear failed: ${e?.message ?? e?.code}`);
+        }
       }
-      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);
+    } finally {
+      client.releaseSelectionLock();
     }
-    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;
@@ -3608,6 +4857,15 @@ var bulkEnrichStatus = {
         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.kind === "qualify") {
+      return {
+        error: true,
+        code: "BULK_WRONG_KIND",
+        message: "This bulk_id was created by leadbay_import_and_qualify, not leadbay_enrich_titles.",
+        hint: "Call leadbay_qualify_status with this id instead.",
+        bulk_id: record.bulk_id
+      };
+    }
     if (record.status === "pending") {
       return {
         error: true,
@@ -4236,7 +5494,8 @@ var granularReadTools = [
   getProspectingActions,
   getWebFetch,
   getSelectionIds,
-  getEnrichmentJobTitles
+  getEnrichmentJobTitles,
+  listMappableFields
 ];
 var granularWriteTools = [
   qualifyLead,
@@ -4274,6 +5533,11 @@ var compositeReadTools = [
   recallOrderedTitles,
   accountStatus,
   bulkEnrichStatus,
+  qualifyStatus,
+  // listMappableFields is granular-shaped but the import composites depend on
+  // it for discoverability; expose it always-on so agents can find custom fields
+  // without needing LEADBAY_MCP_ADVANCED=1.
+  listMappableFields,
   // Keep the existing composites available too.
   researchCompany,
   prepareOutreach
@@ -4285,7 +5549,8 @@ var compositeWriteTools = [
   refinePrompt,
   answerClarification,
   reportOutreach,
-  importLeads
+  importLeads,
+  importAndQualify
 ];
 var compositeTools = [
   ...compositeReadTools,
@@ -4323,6 +5588,8 @@ export {
   getWebFetch,
   getSelectionIds,
   getEnrichmentJobTitles,
+  importLeads,
+  listMappableFields,
   selectLeads,
   deselectLeads,
   clearSelection,
@@ -4347,12 +5614,13 @@ export {
   recallOrderedTitles,
   accountStatus,
   bulkQualifyLeads,
-  importLeads,
-  enrichTitles,
+  importAndQualify,
   isValidBulkId,
   LocalBulkStore,
   InMemoryBulkStore,
   createDefaultBulkStore,
+  qualifyStatus,
+  enrichTitles,
   bulkEnrichStatus,
   adjustAudience,
   refinePrompt,