@leadbay/mcp 0.6.2 → 0.6.3

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog — @leadbay/mcp
 
-## 0.6.2 — UNRELEASED
+## 0.6.3 — 2026-05-12
+
+**Async import schema fix**: `leadbay_import_leads` now declares both its legacy blocking result shape and its async kickoff shape (`{status: "running", handle_id, importIds, progress}`) in `outputSchema`, so Claude Desktop and other MCP SDK clients accept the fast handle response instead of rejecting `structuredContent`.
+
+**Async qualification schema fix**: `leadbay_bulk_qualify_leads` now also declares its async kickoff shape (`{status: "running", handle_id, qualify_id, ...}`), matching the `wait_for_completion:false` behavior added for short MCP client transport timeouts.
+
+## 0.6.2 — 2026-05-12
 
 **MCPB install fix**: desktop extension bundles now use the current `manifest_version` field and remove unsupported manifest keys (`user_config.*.enum` and an internal note field) so Claude Desktop can preview and install the MCPB.
 

package/dist/bin.js

@@ -8,7 +8,7 @@ import {
   granularReadTools,
   granularWriteTools,
   resolveRegion
-} from "./chunk-NLG7GUZ3.js";
+} from "./chunk-QAOJARMK.js";
 
 // src/bin.ts
 import { realpathSync } from "fs";
@@ -587,7 +587,7 @@ function buildServer(client, opts = {}) {
 
 // src/bin.ts
 import { createRequire } from "module";
-var VERSION = "0.6.2";
+var VERSION = "0.6.3";
 var HELP = `
 leadbay-mcp ${VERSION} \u2014 Leadbay Model Context Protocol server
 
@@ -876,7 +876,7 @@ async function runLogin(args) {
   let result;
   try {
     if (pinnedRegion && !allowFallback) {
-      const { REGIONS } = await import("./dist-JUTSXWBL.js");
+      const { REGIONS } = await import("./dist-KHXRELXF.js");
       const baseUrl = REGIONS[pinnedRegion];
       const c = createClient({ region: pinnedRegion });
       const token = await loginAt(baseUrl, email, password);
@@ -1368,7 +1368,7 @@ leadbay-mcp install \u2014 detected MCP clients on this machine:
   let region;
   try {
     if (pinnedRegion && !allowFallback) {
-      const { REGIONS } = await import("./dist-JUTSXWBL.js");
+      const { REGIONS } = await import("./dist-KHXRELXF.js");
       const baseUrl = REGIONS[pinnedRegion];
       token = await loginAt(baseUrl, email, password);
       region = pinnedRegion;

package/dist/{chunk-NLG7GUZ3.js → chunk-QAOJARMK.js}

@@ -1871,7 +1871,10 @@ async function refreshLeadStates(client, leadIds, questionOrder) {
 }
 
 // ../core/dist/composite/import-leads.js
-import { randomUUID } from "crypto";
+import { createHash as createHash2, randomUUID } from "crypto";
+function isImportLeadsRunningResult(result) {
+  return "status" in result && result.status === "running";
+}
 var CHUNK_SIZE = 100;
 var POLL_INTERVAL_MS2 = 2e3;
 var DEFAULT_PER_PHASE_BUDGET_MS = 6e4;
@@ -1972,6 +1975,29 @@ function chunkAt100(items) {
   }
   return chunks;
 }
+function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map(stableStringify).join(",")}]`;
+  const obj = value;
+  return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function importFingerprint(params, prep) {
+  const payload = {
+    mode: prep.mode,
+    rows: prep.validInputs.map((i) => ({
+      domain: i.domain,
+      outputDomain: i.outputDomain,
+      row: i.row
+    })),
+    malformed: prep.malformedDomains,
+    header: prep.header,
+    mappings: prep.mappings,
+    dry_run: Boolean(params.dry_run)
+  };
+  return createHash2("sha256").update(stableStringify(payload)).digest("hex");
+}
 function checkAborted(signal) {
   if (signal?.aborted) {
     throw Object.assign(new Error("aborted"), { name: "AbortError" });
@@ -2339,6 +2365,10 @@ async function pollRecordsToTerminal(client, importId, budgetMs, expectedRowCoun
   }
 }
 async function runOneChunk(client, chunk, chunkIdx, totalChunks, header, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onImportId) {
+  const upload = await uploadOneChunk(client, chunk, chunkIdx, totalChunks, header, ctx, onImportId);
+  return completeUploadedChunk(client, upload, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal);
+}
+async function uploadOneChunk(client, chunk, chunkIdx, totalChunks, header, ctx, 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`;
@@ -2346,6 +2376,10 @@ async function runOneChunk(client, chunk, chunkIdx, totalChunks, header, mapping
   const upload = await client.requestRawBinary("POST", `/imports?file_name=${encodeURIComponent(fileName)}`, "text/csv", csv);
   const importId = upload.id;
   onImportId(importId);
+  return { importId, chunk, chunkIdx, totalChunks };
+}
+async function completeUploadedChunk(client, upload, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal) {
+  const { importId, chunk } = upload;
   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}`);
@@ -2416,6 +2450,82 @@ function reconcileOneChunk(prep, chunk, matched, notImported) {
     }
   }
 }
+function buildImportLeadsResult(client, prep, importIds, matched, notImported, dryRun, cancelled) {
+  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
+    }
+  };
+}
 var importLeads = {
   name: "leadbay_import_leads",
   annotations: {
@@ -2428,7 +2538,7 @@ var importLeads = {
     idempotentHint: true,
     openWorldHint: true
   },
-  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.",
+  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. For MCP clients with short transport timeouts, pass `wait_for_completion:false` to return quickly with `{status:'running', handle_id}`; poll `leadbay_import_status` with that handle for progress and the final `{leads, not_imported, importIds}` result.\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: {
@@ -2494,6 +2604,10 @@ var importLeads = {
       total_budget_ms: {
         type: "number",
         description: `Overall cap across all phases (default ${DEFAULT_TOTAL_BUDGET_MS}ms).`
+      },
+      wait_for_completion: {
+        type: "boolean",
+        description: "When false, validate and enqueue the import in the background, then return `{status:'running', handle_id}` immediately. Poll leadbay_import_status(handle_id). Default is true for 0.6.x backwards compatibility."
       }
     },
     // Neither field is "required" at the schema level; xor + presence is
@@ -2508,6 +2622,18 @@ var importLeads = {
         description: "Imported leads. Domains mode: [{domain, leadId, name}]. Records mode: [{rowId, domain?, leadId, name}].",
         items: { type: "object" }
       },
+      status: {
+        type: "string",
+        description: "`running` when wait_for_completion=false; absent on the legacy blocking result."
+      },
+      handle_id: {
+        type: "string",
+        description: "Persisted UUID handle to pass to leadbay_import_status."
+      },
+      progress: {
+        type: "object",
+        description: "Current async import progress when wait_for_completion=false."
+      },
       not_imported: {
         type: "array",
         description: "Inputs that did NOT yield a leadId. Each entry has a `reason` ('malformed', 'NO_MATCH', 'TIMEOUT', etc.) plus the input echo.",
@@ -2529,7 +2655,11 @@ var importLeads = {
       },
       _meta: { type: "object" }
     },
-    required: ["leads", "not_imported", "importIds", "region", "_meta"]
+    required: ["importIds", "region", "_meta"],
+    anyOf: [
+      { required: ["leads", "not_imported", "importIds", "region", "_meta"] },
+      { required: ["status", "handle_id", "importIds", "progress", "region", "_meta"] }
+    ]
   },
   execute: async (client, params, ctx) => {
     const signal = ctx?.signal;
@@ -2537,6 +2667,7 @@ var importLeads = {
     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 waitForCompletion = params.wait_for_completion ?? true;
     const hasDomains = Array.isArray(params.domains) && params.domains.length > 0;
     const hasRecords = Array.isArray(params.records) && params.records.length > 0;
     if (hasDomains && hasRecords) {
@@ -2563,13 +2694,13 @@ var importLeads = {
     }
     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) => ({
+      const not_imported = prep.malformedDomains.map((d) => ({
         domain: d,
         reason: "malformed"
       }));
       return {
         leads: [],
-        not_imported: not_imported2,
+        not_imported,
         importIds: [],
         region: client.region,
         dry_run: dryRun || void 0,
@@ -2582,6 +2713,67 @@ var importLeads = {
       };
     }
     const chunks = chunkAt100(prep.validInputs);
+    if (!waitForCompletion) {
+      if (!ctx?.bulkTracker) {
+        throw client.makeError("BULK_TRACKER_UNAVAILABLE", "No BulkTracker configured on this MCP instance", "leadbay_import_leads wait_for_completion=false needs a BulkTracker so the handle survives restart.", "");
+      }
+      const reservation = await ctx.bulkTracker.findOrCreatePendingImport({
+        import_fingerprint: importFingerprint(params, prep),
+        mode: prep.mode,
+        dry_run: dryRun,
+        records_total: prep.validInputs.length
+      });
+      const importIds2 = [...reservation.record.import_ids];
+      const uploadedChunks = [];
+      if (!reservation.reused || reservation.record.import_ids.length === 0) {
+        try {
+          for (let i = 0; i < chunks.length; i++) {
+            const upload = await uploadOneChunk(client, chunks[i], i, chunks.length, prep.header, ctx, (id) => {
+              if (!importIds2.includes(id))
+                importIds2.push(id);
+            });
+            uploadedChunks.push(upload);
+            await ctx.bulkTracker.setImportIds(reservation.record.bulk_id, importIds2);
+          }
+          await ctx.bulkTracker.setImportProgress(reservation.record.bulk_id, {
+            phase: "preprocess",
+            records_processed: 0,
+            records_total: prep.validInputs.length
+          });
+        } catch (err) {
+          await ctx.bulkTracker.markImportFailed(reservation.record.bulk_id, err?.message ?? err?.code ?? "unknown");
+          throw err;
+        }
+      }
+      if (uploadedChunks.length > 0) {
+        void runImportInBackground(client, prep, uploadedChunks, {
+          dryRun,
+          perPhaseBudget,
+          totalBudget
+        }, ctx, reservation.record.bulk_id);
+      }
+      return {
+        status: "running",
+        handle_id: reservation.record.bulk_id,
+        importIds: importIds2,
+        progress: {
+          phase: reservation.record.status === "complete" ? "complete" : importIds2.length > 0 ? "preprocess" : "queued",
+          records_processed: reservation.record.status === "complete" ? reservation.record.records_total : 0,
+          records_total: reservation.record.records_total
+        },
+        region: client.region,
+        ...reservation.reused ? {
+          reused: true,
+          seconds_since_original: reservation.seconds_since_original
+        } : {},
+        _meta: client.lastMeta ?? {
+          region: client.region,
+          endpoint: "POST /imports",
+          latency_ms: null,
+          retry_after: null
+        }
+      };
+    }
     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();
@@ -2615,82 +2807,45 @@ var importLeads = {
         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);
+    return buildImportLeadsResult(client, prep, importIds, matched, notImported, dryRun, cancelled);
+  }
+};
+async function runImportInBackground(client, prep, uploadedChunks, opts, ctx, handleId) {
+  const tracker = ctx.bulkTracker;
+  if (!tracker)
+    return;
+  void tracker.setImportProgress(handleId, {
+    phase: "preprocess",
+    records_processed: 0,
+    records_total: prep.validInputs.length
+  }).catch(() => {
+  });
+  setTimeout(() => {
+    void (async () => {
+      const bgCtx = { logger: ctx.logger, bulkTracker: tracker };
+      const importIds = uploadedChunks.map((chunk) => chunk.importId);
+      const matched = /* @__PURE__ */ new Map();
+      const notImported = /* @__PURE__ */ new Map();
+      try {
+        const totalDeadline = Date.now() + opts.totalBudget;
+        for (const upload of uploadedChunks) {
+          const out = await completeUploadedChunk(client, upload, prep.mappings, opts.dryRun, opts.perPhaseBudget, totalDeadline, bgCtx, void 0);
+          if (!opts.dryRun) {
+            reconcileOneChunk(prep, out, matched, notImported);
           }
-          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);
         }
+        const result = buildImportLeadsResult(client, prep, importIds, matched, notImported, opts.dryRun, false);
+        await tracker.markImportComplete(handleId, {
+          leads: result.leads,
+          not_imported: result.not_imported,
+          importIds: result.importIds
+        });
+      } catch (err) {
+        await tracker.markImportFailed(handleId, err?.message ?? err?.code ?? "unknown");
       }
-    }
-    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
-      }
-    };
-  }
-};
+    })();
+  }, 0);
+}
 
 // ../core/dist/tools/list-mappable-fields.js
 var STANDARD_FIELDS = [
@@ -4490,7 +4645,7 @@ var bulkQualifyLeads = {
     idempotentHint: true,
     openWorldHint: true
   },
-  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).",
+  description: "Pick the next N unqualified leads in the active lens and qualify them (run AI rescore + web fetch). Pass `wait_for_completion:false` to return quickly with `{status:'running', qualify_id}`; poll leadbay_qualify_status with that id. With wait_for_completion omitted/true, the legacy behavior polls until the answers are populated or a budget is exhausted. Already-qualified leads (those with a non-null ai_agent_lead_score) are silently no-ops on the backend, so this composite paginates past them to find fresh candidates. On 429 mid-fanout, stops launching but keeps polling already-launched leads. Context: Leadbay auto-qualifies roughly the top 10 of each daily batch. Leads below the top ~10 are NOT worse \u2014 the system is saving resources. This tool is how the agent spends more resources to go deeper on promising-looking leads the user hasn't had time to surface yet. When to use: when the user wants more qualified leads than what's currently shown, or when a lead looks promising in leadbay_pull_leads but has an empty qualification_summary. When NOT to use: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced).",
   inputSchema: {
     type: "object",
     properties: {
@@ -4514,6 +4669,10 @@ var bulkQualifyLeads = {
       total_budget_ms: {
         type: "number",
         description: `Total polling budget in ms (default ${DEFAULT_TOTAL_BUDGET_MS2})`
+      },
+      wait_for_completion: {
+        type: "boolean",
+        description: "When false, launch qualification and return `{status:'running', qualify_id}` immediately. Poll leadbay_qualify_status. Default is true for 0.6.x backwards compatibility."
       }
     },
     additionalProperties: false
@@ -4526,6 +4685,14 @@ var bulkQualifyLeads = {
         description: "Leads whose qualification finished within budget. Each entry: lead_id, qualification_summary{answered,total,avg_qualification_boost}, signals_count.",
         items: { type: "object" }
       },
+      status: {
+        type: "string",
+        description: "`running` when wait_for_completion=false; absent on the legacy blocking result."
+      },
+      handle_id: { type: "string", description: "Alias of qualify_id for handle-oriented callers." },
+      qualify_id: { type: "string", description: "UUIDv4 to poll via leadbay_qualify_status." },
+      lead_ids: { type: "array", items: { type: "string" } },
+      launched_count: { type: "number" },
       still_running: {
         type: "array",
         description: "Leads launched but whose qualification did not complete within budget. Re-poll via leadbay_qualify_status with the bulk_id (when present).",
@@ -4556,13 +4723,30 @@ var bulkQualifyLeads = {
         properties: { region: { type: "string" } }
       }
     },
-    required: ["qualified", "still_running", "failed", "quota_exceeded"]
+    required: ["failed", "quota_exceeded"],
+    anyOf: [
+      { required: ["qualified", "still_running", "failed", "quota_exceeded"] },
+      {
+        required: [
+          "status",
+          "handle_id",
+          "qualify_id",
+          "lead_ids",
+          "launched_count",
+          "failed",
+          "quota_exceeded",
+          "lens_id",
+          "_meta"
+        ]
+      }
+    ]
   },
   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_MS2;
     const totalDeadline = Date.now() + totalBudget;
+    const waitForCompletion = params.wait_for_completion ?? true;
     let candidates;
     let exhausted = false;
     let totalUnqualifiedFound = 0;
@@ -4605,6 +4789,58 @@ var bulkQualifyLeads = {
         message: "No unqualified leads found in this lens \u2014 either all leads have been qualified, or the wishlist is still computing (check leadbay_account_status for computing_wishlist)."
       };
     }
+    if (!waitForCompletion) {
+      if (!ctx?.bulkTracker) {
+        throw client.makeError("BULK_TRACKER_UNAVAILABLE", "No BulkTracker configured on this MCP instance", "leadbay_bulk_qualify_leads wait_for_completion=false needs a BulkTracker so qualify_id survives restart.", "");
+      }
+      const reservation = await ctx.bulkTracker.findOrCreatePendingQualify({
+        lead_ids: candidates,
+        import_ids: [],
+        lens_id: lensId,
+        mapping_fingerprint: "bulk_qualify_leads",
+        per_lead_budget_ms: perLeadBudget,
+        total_budget_ms: totalBudget
+      });
+      const launched2 = [];
+      const failed2 = [];
+      let quotaExceeded2 = false;
+      if (!reservation.reused) {
+        for (const leadId of candidates) {
+          if (quotaExceeded2)
+            break;
+          try {
+            await client.requestVoid("POST", `/leads/${leadId}/web_fetch?force_fetch=false`);
+            launched2.push(leadId);
+          } catch (err) {
+            if (err?.code === "QUOTA_EXCEEDED") {
+              quotaExceeded2 = true;
+            } else if (err?.code === "NOT_FOUND") {
+              failed2.push({ lead_id: leadId, error: "lead not found" });
+            } else {
+              failed2.push({
+                lead_id: leadId,
+                error: err?.message ?? err?.code ?? "unknown"
+              });
+            }
+          }
+        }
+        if (failed2.length === candidates.length || launched2.length > 0 || quotaExceeded2) {
+          await ctx.bulkTracker.markLaunched(reservation.record.bulk_id);
+        }
+      }
+      const out = {
+        status: "running",
+        handle_id: reservation.record.bulk_id,
+        qualify_id: reservation.record.bulk_id,
+        lead_ids: candidates,
+        launched_count: reservation.reused ? reservation.record.lead_ids.length : launched2.length,
+        failed: failed2,
+        quota_exceeded: quotaExceeded2,
+        lens_id: lensId,
+        _meta: { region: client.region }
+      };
+      return out;
+    }
     const launched = [];
     const failed = [];
     let quotaExceeded = false;
@@ -4799,7 +5035,7 @@ var importAndQualify = {
     idempotentHint: true,
     openWorldHint: true
   },
-  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.
+  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. For MCP clients with short transport timeouts, pass \`wait_for_completion:false\`; the tool returns quickly with an import \`handle_id\` that can be polled with leadbay_import_status before continuing qualification. 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\`.
@@ -4887,6 +5123,10 @@ Requires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role;
         type: "number",
         description: `Per-phase budget for the import wizard (default ${DEFAULT_PER_PHASE_BUDGET_MS2}); mirrors leadbay_import_leads.`
       },
+      wait_for_completion: {
+        type: "boolean",
+        description: "When false, enqueue the import phase and return `{kind:'result', status:'running', handle_id}` immediately. Poll leadbay_import_status. Default is true for 0.6.x backwards compatibility."
+      },
       lensId: {
         type: "number",
         description: "Lens id (escape hatch \u2014 defaults to active)."
@@ -4909,6 +5149,14 @@ Requires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role;
         type: "string",
         description: "'result' (full flow) or 'preview' (dry_run='preview' mapping diagnostics)."
       },
+      status: {
+        type: "string",
+        description: "`running` when wait_for_completion=false."
+      },
+      handle_id: {
+        type: "string",
+        description: "Import handle to pass to leadbay_import_status when wait_for_completion=false."
+      },
       // preview-shape keys
       mapping_hints: {
         type: "array",
@@ -5015,19 +5263,76 @@ Requires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role;
     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.", "");
     }
+    if (params.wait_for_completion === false) {
+      const queued = 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 } : {},
+        wait_for_completion: false
+      }, ctx);
+      if (!isImportLeadsRunningResult(queued)) {
+        return {
+          kind: "result",
+          ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
+          qualify_id: null,
+          import_ids: queued.importIds,
+          imported: queued.leads.map((l) => ({
+            leadId: l.leadId,
+            ...l.domain ? { domain: l.domain } : {},
+            name: l.name ?? null,
+            ...l.rowId ? { rowId: l.rowId } : {}
+          })),
+          not_imported: queued.not_imported.map(toNotImportedEntry),
+          qualified: [],
+          still_running: [],
+          failed: [],
+          quota_exceeded: false,
+          skipped_already_qualified: [],
+          not_in_lens: [],
+          region: client.region,
+          _meta: queued._meta
+        };
+      }
+      return {
+        kind: "result",
+        status: "running",
+        handle_id: queued.handle_id,
+        ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
+        qualify_id: null,
+        import_ids: queued.importIds,
+        imported: [],
+        not_imported: [],
+        qualified: [],
+        still_running: [],
+        failed: [],
+        quota_exceeded: false,
+        skipped_already_qualified: [],
+        not_in_lens: [],
+        region: client.region,
+        _meta: queued._meta
+      };
+    }
     ctx?.progress?.({
       progress: 1,
       total: 3,
       message: "Importing leads (phase 1/3 \u2014 preprocess + commit)"
     });
-    const importResult = await importLeads.execute(client, {
+    const importResultRaw = 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 } : {}
+      ...params.dry_run === true ? { dry_run: true } : {},
+      wait_for_completion: true
     }, ctx);
+    if (isImportLeadsRunningResult(importResultRaw)) {
+      throw client.makeError("IMPORT_ASYNC_UNEXPECTED", "Import returned an async handle while import_and_qualify was waiting for completion", "Retry with wait_for_completion=false and poll leadbay_import_status, or retry the blocking call.", "POST /imports");
+    }
+    const importResult = importResultRaw;
     if (importResult.cancelled) {
       return {
         kind: "result",
@@ -5320,7 +5625,7 @@ import { mkdir as mkdirAsync, lstat, open as fsOpen, readFile, rename, stat, unl
 import { constants as fsConstants } from "fs";
 import { dirname, resolve as resolvePath } from "path";
 import { homedir, platform } from "os";
-import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash3, 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;
@@ -5335,7 +5640,7 @@ function computeIdempotencyKey(args) {
     args.phone ? "p1" : "p0",
     `l${args.lens_id}`
   ];
-  return createHash2("sha256").update(parts.join("|")).digest("hex");
+  return createHash3("sha256").update(parts.join("|")).digest("hex");
 }
 function computeQualifyIdempotencyKey(args) {
   const parts = [
@@ -5345,7 +5650,16 @@ function computeQualifyIdempotencyKey(args) {
     `l${args.lens_id}`,
     args.mapping_fingerprint
   ];
-  return createHash2("sha256").update(parts.join("|")).digest("hex");
+  return createHash3("sha256").update(parts.join("|")).digest("hex");
+}
+function computeImportIdempotencyKey(args) {
+  const parts = [
+    "import",
+    args.mode,
+    args.dry_run ? "dry1" : "dry0",
+    args.import_fingerprint
+  ];
+  return createHash3("sha256").update(parts.join("|")).digest("hex");
 }
 function normalizeLaunchInputs(args) {
   return {
@@ -5483,7 +5797,7 @@ var LocalBulkStore = class {
       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")
+    if (r.status !== "pending" && r.status !== "launched" && r.status !== "complete" && r.status !== "failed" && r.status !== "cancelled")
       throw new Error("invalid status");
     if (typeof r.idempotency_key !== "string")
       throw new Error("invalid idempotency_key");
@@ -5510,6 +5824,52 @@ var LocalBulkStore = class {
         out.total_budget_ms = r.total_budget_ms;
       return out;
     }
+    if (kind === "import") {
+      if (!Array.isArray(r.import_ids) || !r.import_ids.every((x) => typeof x === "string"))
+        throw new Error("invalid import_ids");
+      if (r.mode !== "domains" && r.mode !== "records")
+        throw new Error("invalid mode");
+      if (typeof r.dry_run !== "boolean")
+        throw new Error("invalid dry_run");
+      if (typeof r.records_total !== "number")
+        throw new Error("invalid records_total");
+      const out = {
+        kind: "import",
+        bulk_id: r.bulk_id,
+        launched_at: r.launched_at,
+        lead_ids: r.lead_ids,
+        import_ids: r.import_ids,
+        mode: r.mode,
+        dry_run: r.dry_run,
+        records_total: r.records_total,
+        status: r.status,
+        idempotency_key: r.idempotency_key,
+        durability: this.backend
+      };
+      if (r.result && typeof r.result === "object") {
+        const result = r.result;
+        if (Array.isArray(result.leads) && Array.isArray(result.not_imported) && Array.isArray(result.importIds) && result.importIds.every((x) => typeof x === "string")) {
+          out.result = {
+            leads: result.leads,
+            not_imported: result.not_imported,
+            importIds: result.importIds
+          };
+        }
+      }
+      if (r.progress && typeof r.progress === "object") {
+        const p = r.progress;
+        if (typeof p.phase === "string" && typeof p.records_processed === "number" && typeof p.records_total === "number") {
+          out.progress = {
+            phase: p.phase,
+            records_processed: p.records_processed,
+            records_total: p.records_total
+          };
+        }
+      }
+      if (typeof r.error === "string")
+        out.error = r.error;
+      return out;
+    }
     if (kind === "enrich") {
       if (!Array.isArray(r.titles) || !r.titles.every((x) => typeof x === "string"))
         throw new Error("invalid titles");
@@ -5673,10 +6033,119 @@ var LocalBulkStore = class {
       return { record, reused: false };
     });
   }
+  async findOrCreatePendingImport(args) {
+    const idempotency_key = computeImportIdempotencyKey({
+      import_fingerprint: args.import_fingerprint,
+      mode: args.mode,
+      dry_run: args.dry_run
+    });
+    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 === "import" && r.idempotency_key === idempotency_key && r.status !== "failed" && r.status !== "cancelled" && nowMs - Date.parse(r.launched_at) < window);
+      if (existing) {
+        this.logger?.info?.(`bulk.reused kind=import 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: "import",
+        bulk_id: randomUUID2(),
+        launched_at: new Date(nowMs).toISOString(),
+        lead_ids: [],
+        import_ids: [],
+        mode: args.mode,
+        dry_run: args.dry_run,
+        records_total: args.records_total,
+        progress: {
+          phase: "queued",
+          records_processed: 0,
+          records_total: args.records_total
+        },
+        status: "pending",
+        idempotency_key,
+        durability: this.backend
+      };
+      all.push(record);
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.registered kind=import bulk_id=${record.bulk_id} mode=${record.mode} records_total=${record.records_total} 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 getImport(bulk_id) {
+    const r = await this.get(bulk_id);
+    return r && r.kind === "import" ? r : void 0;
+  }
+  async setImportIds(bulk_id, import_ids) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const idx = all.findIndex((r) => r.bulk_id === bulk_id && r.kind === "import");
+      if (idx < 0)
+        throw new Error(`import bulk_id not found: ${bulk_id}`);
+      const record = all[idx];
+      all[idx] = {
+        ...record,
+        import_ids: [...new Set(import_ids)].sort(),
+        status: record.status === "pending" ? "launched" : record.status
+      };
+      await this.writeAll(all);
+      return all[idx];
+    });
+  }
+  async setImportProgress(bulk_id, progress) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const idx = all.findIndex((r) => r.bulk_id === bulk_id && r.kind === "import");
+      if (idx < 0)
+        throw new Error(`import bulk_id not found: ${bulk_id}`);
+      const record = all[idx];
+      all[idx] = { ...record, progress };
+      await this.writeAll(all);
+      return all[idx];
+    });
+  }
+  async markImportComplete(bulk_id, result) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const idx = all.findIndex((r) => r.bulk_id === bulk_id && r.kind === "import");
+      if (idx < 0)
+        throw new Error(`import bulk_id not found: ${bulk_id}`);
+      const record = all[idx];
+      all[idx] = {
+        ...record,
+        import_ids: [...new Set(result.importIds)].sort(),
+        result,
+        progress: {
+          phase: "complete",
+          records_processed: record.records_total,
+          records_total: record.records_total
+        },
+        status: "complete"
+      };
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.import_complete bulk_id=${bulk_id}`);
+      return all[idx];
+    });
+  }
+  async markImportFailed(bulk_id, error) {
+    return this.mutex.run(async () => {
+      const all = this.prune(await this.readAll());
+      const idx = all.findIndex((r) => r.bulk_id === bulk_id && r.kind === "import");
+      if (idx < 0)
+        return;
+      all[idx] = { ...all[idx], status: "failed", error };
+      await this.writeAll(all);
+      this.logger?.info?.(`bulk.import_failed bulk_id=${bulk_id}`);
+    });
+  }
   async markLaunched(bulk_id) {
     return this.mutex.run(async () => {
       const all = this.prune(await this.readAll());
@@ -5770,6 +6239,200 @@ async function createDefaultBulkStore(opts = {}) {
   }
 }
 
+// ../core/dist/composite/import-status.js
+function summarizeImports(imports, dryRun) {
+  let recordsTotal = 0;
+  let recordsProcessed = 0;
+  let hasPreprocess = false;
+  let hasProcess = false;
+  let hasFailed = false;
+  for (const imp of imports) {
+    recordsTotal += Number(imp.total_records ?? 0);
+    recordsProcessed += Number(imp.imported_records ?? 0);
+    if (!imp.pre_processing?.finished) {
+      hasPreprocess = true;
+      continue;
+    }
+    if (imp.pre_processing?.error) {
+      hasFailed = true;
+      continue;
+    }
+    if (dryRun === true) {
+      continue;
+    }
+    if (!imp.processing?.finished) {
+      if (dryRun === false || imp.processing != null)
+        hasProcess = true;
+      continue;
+    }
+    if (imp.processing?.error) {
+      hasFailed = true;
+    }
+  }
+  const phase = hasFailed ? "failed" : hasPreprocess ? "preprocess" : hasProcess ? "process" : imports.length > 0 ? "complete" : "queued";
+  return {
+    phase,
+    records_processed: recordsProcessed,
+    records_total: recordsTotal
+  };
+}
+var importStatus = {
+  name: "leadbay_import_status",
+  annotations: {
+    title: "Poll import status",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  description: "Retrieve the current state of an async lead import. Pass `handle_id` returned by leadbay_import_leads({wait_for_completion:false}), or pass legacy `importIds[]` to inspect backend wizard rows. This status call performs a single refresh pass and never polls in a loop.\nWhen to use: after leadbay_import_leads or leadbay_import_and_qualify returns `{status:'running', handle_id}` for the import phase, call this tool later to retrieve progress or the final import result without re-running the import.\nWhen NOT to use: for qualification handles returned as `qualify_id` \u2014 use leadbay_qualify_status for those; or when you still want the legacy blocking behavior from leadbay_import_leads with wait_for_completion=true.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      handle_id: {
+        type: "string",
+        description: "UUIDv4 handle returned by leadbay_import_leads when wait_for_completion=false."
+      },
+      importIds: {
+        type: "array",
+        description: "Legacy backend file-import ids to inspect directly.",
+        items: { type: "string" }
+      }
+    },
+    additionalProperties: false
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      status: { type: "string", description: "running, complete, or failed." },
+      handle_id: { type: "string" },
+      importIds: { type: "array", items: { type: "string" } },
+      progress: { type: "object" },
+      result: {
+        type: "object",
+        description: "Final import result when the handle has completed in this MCP instance."
+      },
+      error: { type: "string" },
+      region: { type: "string" },
+      _meta: { type: "object" }
+    },
+    required: ["status", "importIds", "progress", "region", "_meta"]
+  },
+  execute: async (client, params, ctx) => {
+    let handleId = params.handle_id;
+    let importIds = params.importIds ?? [];
+    let handleDryRun;
+    if (handleId) {
+      if (!isValidBulkId(handleId)) {
+        throw client.makeError("BULK_INVALID_ID", "handle_id is not a valid UUIDv4", "Pass the handle_id returned by leadbay_import_leads verbatim.", "");
+      }
+      if (!ctx?.bulkTracker) {
+        throw client.makeError("BULK_TRACKER_UNAVAILABLE", "No BulkTracker configured on this MCP instance", "leadbay_import_status needs a BulkTracker to resolve handle_id. Pass importIds[] directly as a fallback.", "");
+      }
+      const record = await ctx.bulkTracker.getImport(handleId);
+      if (!record) {
+        const any = await ctx.bulkTracker.get(handleId);
+        if (any && any.kind !== "import") {
+          throw client.makeError("BULK_WRONG_KIND", "This handle was not created by leadbay_import_leads", "Use leadbay_qualify_status for qualify ids or leadbay_bulk_enrich_status for enrich ids.", "");
+        }
+        throw client.makeError("BULK_NOT_FOUND", "No import record for that handle_id", "It may have expired (30-day TTL) or the MCP process was restarted without persistence.", "");
+      }
+      importIds = record.import_ids;
+      handleDryRun = record.dry_run;
+      if (record.status === "complete" && record.result) {
+        return {
+          status: "complete",
+          handle_id: handleId,
+          importIds,
+          progress: record.progress ?? {
+            phase: "complete",
+            records_processed: record.records_total,
+            records_total: record.records_total
+          },
+          result: record.result,
+          region: client.region,
+          _meta: client.lastMeta ?? {
+            region: client.region,
+            endpoint: "bulk-store",
+            latency_ms: null,
+            retry_after: null
+          }
+        };
+      }
+      if (record.status === "failed") {
+        return {
+          status: "failed",
+          handle_id: handleId,
+          importIds,
+          progress: record.progress ?? {
+            phase: "failed",
+            records_processed: 0,
+            records_total: record.records_total
+          },
+          error: record.error ?? "import failed",
+          region: client.region,
+          _meta: client.lastMeta ?? {
+            region: client.region,
+            endpoint: "bulk-store",
+            latency_ms: null,
+            retry_after: null
+          }
+        };
+      }
+      if (importIds.length === 0) {
+        return {
+          status: "running",
+          handle_id: handleId,
+          importIds,
+          progress: record.progress ?? {
+            phase: "queued",
+            records_processed: 0,
+            records_total: record.records_total
+          },
+          region: client.region,
+          _meta: client.lastMeta ?? {
+            region: client.region,
+            endpoint: "bulk-store",
+            latency_ms: null,
+            retry_after: null
+          }
+        };
+      }
+    }
+    if (importIds.length === 0) {
+      throw client.makeError("IMPORT_STATUS_INPUT_REQUIRED", "Pass either handle_id or importIds[]", "Call leadbay_import_leads with wait_for_completion=false first, then pass its handle_id.", "");
+    }
+    const imports = await Promise.all(importIds.map((id) => client.request("GET", `/imports/${id}`)));
+    const progress = summarizeImports(imports, handleDryRun);
+    const failed = imports.find((i) => i.pre_processing?.error || i.processing?.error);
+    const complete = imports.every((i) => {
+      if (i.pre_processing?.error || i.processing?.error)
+        return false;
+      if (handleDryRun === true)
+        return Boolean(i.pre_processing?.finished);
+      if (handleDryRun === false)
+        return Boolean(i.processing?.finished);
+      return Boolean(i.processing?.finished || i.pre_processing?.finished && !i.processing);
+    });
+    return {
+      status: failed ? "failed" : complete ? "complete" : "running",
+      ...handleId ? { handle_id: handleId } : {},
+      importIds,
+      progress,
+      ...failed ? {
+        error: failed.pre_processing?.error ?? failed.processing?.error ?? "import failed"
+      } : {},
+      region: client.region,
+      _meta: client.lastMeta ?? {
+        region: client.region,
+        endpoint: "GET /imports/<id>",
+        latency_ms: null,
+        retry_after: null
+      }
+    };
+  }
+};
+
 // ../core/dist/composite/qualify-status.js
 var qualifyStatus = {
   name: "leadbay_qualify_status",
@@ -5865,7 +6528,8 @@ var qualifyStatus = {
     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.", "");
+        const hint = any.kind === "import" ? "Call leadbay_import_status with this id instead." : "Call leadbay_bulk_enrich_status with this id instead.";
+        throw client.makeError("BULK_WRONG_KIND", `This bulk_id was created by ${any.kind}, not leadbay_import_and_qualify`, hint, "");
       }
       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.", "");
     }
@@ -5927,7 +6591,7 @@ var qualifyStatus = {
     const out = {
       qualify_id: record.bulk_id,
       launched_at: record.launched_at,
-      status: record.status,
+      status: record.status === "complete" ? "launched" : record.status,
       import_ids: record.import_ids,
       lens_id: record.lens_id,
       lead_ids: record.lead_ids,
@@ -6429,12 +7093,12 @@ 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") {
+    if (record.kind !== "enrich") {
       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.",
+        message: `This bulk_id was created by ${record.kind === "qualify" ? "leadbay_import_and_qualify" : "leadbay_import_leads"}, not leadbay_enrich_titles.`,
+        hint: record.kind === "qualify" ? "Call leadbay_qualify_status with this id instead." : "Call leadbay_import_status with this id instead.",
         bulk_id: record.bulk_id
       };
     }
@@ -7438,6 +8102,7 @@ var compositeReadTools = [
   accountStatus,
   bulkEnrichStatus,
   qualifyStatus,
+  importStatus,
   // 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.
@@ -7523,6 +8188,7 @@ export {
   LocalBulkStore,
   InMemoryBulkStore,
   createDefaultBulkStore,
+  importStatus,
   qualifyStatus,
   enrichTitles,
   bulkEnrichStatus,

package/dist/{dist-JUTSXWBL.js → dist-KHXRELXF.js}

@@ -47,6 +47,7 @@ import {
   granularWriteTools,
   importAndQualify,
   importLeads,
+  importStatus,
   isValidBulkId,
   launchBulkEnrichment,
   listLenses,
@@ -74,7 +75,7 @@ import {
   tools,
   updateLens,
   updateLensFilter
-} from "./chunk-NLG7GUZ3.js";
+} from "./chunk-QAOJARMK.js";
 export {
   InMemoryBulkStore,
   LeadbayClient,
@@ -123,6 +124,7 @@ export {
   granularWriteTools,
   importAndQualify,
   importLeads,
+  importStatus,
   isValidBulkId,
   launchBulkEnrichment,
   listLenses,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leadbay/mcp",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "mcpName": "io.github.leadbay/leadbay-mcp",
   "description": "Model Context Protocol (MCP) server for Leadbay — AI lead discovery, qualification, and enrichment for Claude Desktop, Cursor, and Claude Code.",
   "type": "module",