@leadbay/mcp 0.34.1 → 0.35.1

package/dist/bin.js

@@ -1513,7 +1513,7 @@ Some Leadbay tool responses include a \`_meta.notifications\` array listing **ba
   - \`leadbay_qualify_status\` \u2192 \`still_running\` is empty: every launched lead has finished or failed. (\`in_progress\` also reads \`false\` on the fast path, but it can be \`null\` on the legacy/fallback read \u2014 so treat an empty \`still_running\` as terminal on its own; only require \`in_progress:false\` when that field is actually present.) LIKE imports, large qualification runs are async by design: \`leadbay_bulk_qualify_leads\` defaults to \`wait_for_completion:false\` for \`count > 5\` or chained workflows because blocking can time out, and \`leadbay_qualify_status\` may take minutes/hours. So don't force a long polling loop on a big run \u2014 return the handle/progress and let completion arrive via \`_meta.notifications\` \u2014 UNLESS the user explicitly asked to wait, or it's a small run that finishes quickly. A small \`wait_for_completion:true\` run you can poll to \`still_running\` empty inline.
   - \`leadbay_import_status\` \u2192 \`status:"complete"\` (or \`"failed"\`). BUT imports are the exception to the stay-active loop: a large \`leadbay_import_leads({wait_for_completion:false})\` is meant to return a handle and resolve over minutes, and the tool does ONE refresh pass per call. Don't block the conversation looping on it \u2014 surface the returned progress/handle and let the completion arrive via \`_meta.notifications\` \u2014 UNLESS the user explicitly asked you to wait for the import, or it's a small import that finishes quickly.
 
-  Enrichment polls to completion in-turn BY DEFAULT \u2014 the exception is when the user explicitly said to start it in the background / not wait ("kick it off, I'll check later"), in which case hand back the bulk_id and let completion arrive via \`_meta.notifications\` (only when a notification id exists; if none was returned, tell the user to ask again / that you'll poll later, since nothing will auto-surface). For qualification and imports, poll inline only for small/quick runs or when the user explicitly asked you to wait; otherwise return the handle and let \`_meta.notifications\` deliver it. Either way, the user should never have to ask "is it done yet?" for work you kicked off in the same turn \u2014 you either report it or hand back a clear in-progress handle.
+  Enrichment polls to completion in-turn BY DEFAULT \u2014 the exception is when the user explicitly said to start it in the background / not wait ("kick it off, I'll check later"), in which case hand back the notification_id and let completion arrive via \`_meta.notifications\` (only when a notification id exists; if none was returned, tell the user to ask again / that you'll poll later, since nothing will auto-surface). For qualification and imports, poll inline only for small/quick runs or when the user explicitly asked you to wait; otherwise return the handle and let \`_meta.notifications\` deliver it. Either way, the user should never have to ask "is it done yet?" for work you kicked off in the same turn \u2014 you either report it or hand back a clear in-progress handle.
 
 Also surfaced as a top-level \`notifications\` array on \`leadbay_account_status\` \u2014 same shape, same handling.
 
@@ -1820,23 +1820,57 @@ WHEN TO USE: the user asks for a clickable / interactive artifact, dashboard, or
 
 WHEN NOT TO USE: the user wants a plain data answer (route to leadbay_pull_leads / leadbay_pull_followups) or to log a single real outreach you just did (leadbay_report_outreach).
 `;
-    leadbay_bulk_enrich_status = `Check status + per-lead contacts for a bulk enrichment you previously launched via leadbay_enrich_titles. Returns the \`bulk_id\`, progress per lead (done/total enrichable contacts), and overall progress. When \`include_contacts=true\` (opt-in), includes each contact's email/phone_number/job_title/enrichment.done.
+    leadbay_bulk_enrich_status = `Check status + per-lead contacts for a bulk enrichment you previously launched via leadbay_enrich_titles. Pass the \`notification_id\` for the job counters in one call, and/or the \`lead_ids\` + \`titles\` + \`email\` / \`phone\` the launch returned for per-lead progress. \`lead_ids\` alone is a valid call and is the reliable one: the job lookup is a scan of your recent notifications, so an archived job may not be found, and an enrichment notification does not always carry counters (then the tool answers \`ENRICH_JOB_NO_COUNTERS\` with the backend's running/finished flag and asks for \`lead_ids\`) \u2014 but the leads always answer. When \`include_contacts=true\` (opt-in), includes each contact's email/phone_number/job_title/enrichment.done.
 
-WHEN TO USE: poll this REPEATEDLY after leadbay_enrich_titles returns a \`bulk_id\`, staying active until the job is done \u2014 don't stop after one check, and don't hand the turn back to the user while progress is still climbing. "Done" = \`all_done:true\`, OR \`overall_progress.done\` has held steady across several SPACED polls (~15\u201330s apart) over at least ~90s\u20132 min of elapsed time (some contacts are unresolvable and never flip, so \`all_done\` can stay false forever \u2014 don't spin indefinitely). Do NOT declare a plateau from the first few back-to-back reads: right after launch, \`overall_progress.done\` can sit flat while the backend is still spinning the job up, so space your polls out and give it real elapsed time before treating a flat count as terminal. Also do NOT declare a plateau while the result carries \`partial_failures\` \u2014 a flat \`done\` there means a transient per-lead fetch error (e.g. a 429), NOT an unresolvable contact; keep polling (respecting any \`retry_after\`) or surface it as a temporary status failure, rather than reporting those leads as permanently unresolved. Default \`include_contacts=false\` for the cheap interim polls; set \`include_contacts=true\` on the read you report from to pull each lead's enriched contacts for the completion report.
+WHEN TO USE: poll this REPEATEDLY after leadbay_enrich_titles returns a \`notification_id\`, staying active until the job is done \u2014 don't stop after one check, and don't hand the turn back to the user while progress is still climbing. "Done" = \`all_done:true\`, OR \`overall_progress.done\` has held steady across several SPACED polls (~15\u201330s apart) over at least ~90s\u20132 min of elapsed time (some contacts are unresolvable and never flip, so \`all_done\` can stay false forever \u2014 don't spin indefinitely). Do NOT declare a plateau from the first few back-to-back reads: right after launch, \`overall_progress.done\` can sit flat while the backend is still spinning the job up, so space your polls out and give it real elapsed time before treating a flat count as terminal. Also do NOT declare a plateau while the result carries \`partial_failures\` \u2014 a flat \`done\` there means a transient per-lead fetch error (e.g. a 429), NOT an unresolvable contact; keep polling (respecting any \`retry_after\`) or surface it as a temporary status failure, rather than reporting those leads as permanently unresolved. Default \`include_contacts=false\` for the cheap interim polls; set \`include_contacts=true\` on the read you report from to pull each lead's enriched contacts for the completion report.
 
 WHEN NOT TO USE: as a substitute for leadbay_research_lead_by_id \u2014 that already includes enriched contacts for a single lead.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. A job started by \`leadbay_enrich_titles\`,
+\`leadbay_bulk_qualify_leads\`, \`leadbay_import_leads\` or
+\`leadbay_import_and_qualify\` runs to completion on Leadbay. The user cancelling
+in the chat, a request timeout, or a closed stream stops YOUR waiting, never the
+job, and \`cancelled: true\` on an earlier result means we stopped watching, not
+that the work stopped.
+
+**This tool only reads.** Calling it again launches nothing and spends no quota,
+so poll it as often as the job needs \u2014 a timeout here is a reason to call it
+again, not a reason to stop.
+
+One import state does NOT progress: a chunk cancelled before its mappings were
+committed reads \`running\` / \`committing\` forever. If the counts hold flat across
+several spaced polls, say so and stop, rather than polling on.
+
+What must not be repeated is the LAUNCH \u2014 for work that actually launched. Re-run
+a launcher only for a subset that never started, never for the whole batch:
+
+- \`failed[]\` entries with \`error:"not_queued"\`;
+- a \`rows_pending_upload\` count;
+- leads in \`still_running\` after a CANCELLED \`leadbay_import_and_qualify\`. Its
+  fan-out is sequential, so an interruption leaves the remainder unlaunched and
+  folds them in with the ones that did launch. Nothing in the result tells the
+  two apart, and this tool cannot start either. Wait until the REST of the batch
+  has settled: what launched settles in order, so leads still unanswered after
+  that are the ones that never started. Only then call
+  \`leadbay_bulk_qualify_leads({leadIds, lensId})\` for exactly those ids. A lead
+  that is merely slow looks identical to one that never launched over a few
+  polls, and re-launching it charges the user twice \u2014 when unsure, tell the user
+  rather than guess.
+
+
 ## QUOTA \u2014 show where the user stands after the spend
 
 Enrichment consumes QUOTA (the per-window allowance), not a separate credit wall. Once the job is done (all_done, or a plateau \u2014 see WHEN TO USE), show the user their refreshed quota: call \`leadbay_account_status\` and render the per-window quota it returns (the canonical surface). The result's \`credits_remaining\` field is **advisory internal context only \u2014 do NOT display it**: it comes from \`billing.ai_credits\` (a consumed counter, not remaining), so printing \`_(N credits remaining)_\` can show a fresh/quota-backed account a false "0 remaining." Never render a credits balance; the \`leadbay_account_status\` quota gauge is the only place the user's standing is shown. Do NOT report a "credits used" figure for this run either: the per-contact cost can't be scoped to this specific enrichment (a lead's contact list mixes in earlier runs), so any "X used" number would be misleading. Do the account_status refresh ONCE at completion \u2014 not on every in-progress poll.
 
 ## COMPLETION REPORT \u2014 what to tell the user when the job is done
 
-The result always carries \`overall_progress:{done,total,done_ratio}\` and, with \`include_contacts:true\`, \`leads[]\` each with contacts' \`email\` / \`phone_number\` / \`job_title\` / \`enrichment.done\`. When the read came back on the notification fast path it ALSO carries \`bulk_progress:{total_count,success_count,failure_count,quota_hit_count}\` \u2014 but the legacy per-lead fallback (older records with no \`notification_id\`, or a notification not yet visible) returns NO \`bulk_progress\`, so derive counts from \`overall_progress\` in that case rather than assuming \`bulk_progress\` is present. A contact counts as done only when the REQUESTED channel actually landed \u2014 for a phone run, \`enrichment.done:true\` with no \`phone_number\` is NOT done (the contact may have been email-enriched earlier); read \`email\` / \`phone_number\` against the requested channels, don't rely on the \`enrichment.done\` flag alone (\`overall_progress\` already accounts for this). \`include_contacts\` returns each lead's FULL contact list (it fans out through \`leadbay_get_contacts\`), so it can include contacts of other roles that were enriched in earlier runs \u2014 filter your report to the \`titles\` this bulk enriched (match each contact's \`job_title\`), don't attribute a pre-existing email of an unrelated role to this run. Report it yourself in the SAME turn, without a reprompt and without deferring to a scheduled re-check: name which of the just-enriched contacts now have emails / phones, the done/total counts, and \u2014 if \`bulk_progress\` is present \u2014 any \`quota_hit_count\` (if non-zero, say some contacts were skipped because the quota window was exhausted, and point to \`leadbay_account_status\` for the wait-or-top-up choice). If you stopped on a plateau (not \`all_done\`), say so plainly \u2014 report the resolved contacts and name the ones that didn't resolve, keyed to the requested channel and the returned fields (no \`email\` \u2192 "no email found"; no \`phone_number\` \u2192 "no phone number found") \u2014 rather than implying the job fully finished. Then show refreshed quota via \`leadbay_account_status\` (see QUOTA above); do NOT print a credits-remaining line.
+The result always carries \`overall_progress:{done,total,done_ratio}\` and, with \`include_contacts:true\`, \`leads[]\` each with contacts' \`email\` / \`phone_number\` / \`job_title\` / \`enrichment.done\`. \`bulk_progress:{total_count,success_count,failure_count,quota_hit_count}\` is present only when you passed a \`notification_id\` AND the job was found; derive counts from \`overall_progress\` rather than assuming \`bulk_progress\` is there. With \`lead_ids\`, each entry carries \`enrichment_progress:{done,total}\` \u2014 \`done\` counts only contacts whose REQUESTED channel has landed, scoped to the \`titles\` this run enriched, so a lead's pre-existing CFO email cannot inflate a CEO run. A contact counts as done only when the REQUESTED channel actually landed \u2014 for a phone run, \`enrichment.done:true\` with no \`phone_number\` is NOT done (the contact may have been email-enriched earlier); read \`email\` / \`phone_number\` against the requested channels, don't rely on the \`enrichment.done\` flag alone (\`overall_progress\` already accounts for this). \`include_contacts\` returns each lead's FULL contact list (it fans out through \`leadbay_get_contacts\`), so it can include contacts of other roles that were enriched in earlier runs \u2014 filter your report to the \`titles\` this bulk enriched (match each contact's \`job_title\`), don't attribute a pre-existing email of an unrelated role to this run. Report it yourself in the SAME turn, without a reprompt and without deferring to a scheduled re-check: name which of the just-enriched contacts now have emails / phones, the done/total counts, and \u2014 if \`bulk_progress\` is present \u2014 any \`quota_hit_count\` (if non-zero, say some contacts were skipped because the quota window was exhausted, and point to \`leadbay_account_status\` for the wait-or-top-up choice). If you stopped on a plateau (not \`all_done\`), say so plainly \u2014 report the resolved contacts and name the ones that didn't resolve, keyed to the requested channel and the returned fields (no \`email\` \u2192 "no email found"; no \`phone_number\` \u2192 "no phone number found") \u2014 rather than implying the job fully finished. Then show refreshed quota via \`leadbay_account_status\` (see QUOTA above); do NOT print a credits-remaining line.
 `;
-    leadbay_bulk_qualify_leads = `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.
+    leadbay_bulk_qualify_leads = `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', notification_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.
 
-**Default to \`wait_for_completion:false\`** for any \`count > 5\` or when chained inside a multi-phase workflow \u2014 the blocking default can hit the MCP per-call timeout and surface as \`"Request timed out"\` even when the server is still working fine. The async pattern (capture \`qualify_id\`, poll \`leadbay_qualify_status\` every ~10s) is timeout-proof. Reserve the blocking form for tiny single-digit counts in interactive use.
+**Default to \`wait_for_completion:false\`** for any \`count > 5\` or when chained inside a multi-phase workflow \u2014 the blocking default can hit the MCP per-call timeout and surface as \`"Request timed out"\` even when the server is still working fine. The async pattern (capture \`notification_id\`, poll \`leadbay_qualify_status\` every ~10s) is timeout-proof. Reserve the blocking form for tiny single-digit counts in interactive use.
 
 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.
 
@@ -1844,6 +1878,36 @@ WHEN TO USE: when the user wants more qualified leads than what's currently show
 
 WHEN NOT TO USE: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced).
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 This tool MUTATES state. The caller (agent or human-in-the-loop) is responsible for confirming intent before invocation; the MCP server does not soft-prompt for confirmation. See \`annotations.destructiveHint\`.
 
 
@@ -1865,7 +1929,7 @@ After the status line, propose the obvious refresh / progress-check / recovery a
 
 Specifically for bulk qualify:
 
-- Kicked off async \u2192 \`"\u2713 Qualifying N lead(s) (qualify_id <id>) \u2014 typically ~M minutes. I'll refresh your leads view when it's done."\`
+- Kicked off async \u2192 \`"\u2713 Qualifying N lead(s) (notification_id <id>) \u2014 typically ~M minutes. I'll refresh your leads view when it's done."\`
 - Blocking call returned with answers \u2192 \`"\u2713 Qualified N lead(s). Refresh your leads to see the new \u2756 caps."\`
 - Already-qualified short-circuit \u2192 \`"All N leads are already qualified \u2014 no work to do."\`
 - 429 mid-fanout \u2192 \`"\u26A0 Rate-limited after launching M of N \u2014 already-launched leads will complete; re-call later for the rest."\`
@@ -2328,6 +2392,23 @@ WHEN TO USE: when the user has already picked WHO they want on a company and you
 
 WHEN NOT TO USE: for bulk enrichment by job title across many leads \u2014 use leadbay_enrich_titles, which handles the selection lifecycle and returns a clean preview/launch flow. Not to mark someone as the priority contact \u2014 that is leadbay_pin_contact, and pinning does not enrich anyone.
 
+## A launched job cannot be stopped, and this tool has no retry guard
+
+Leadbay has no cancel. Once this call returns having actually launched, the work
+is queued on Leadbay and runs to completion, and the quota it costs is already
+committed. A \`dry_run\` result reached no backend and spent nothing. The user
+cancelling in the chat, a request timeout, or a closed stream stops YOUR waiting,
+never the job.
+
+Unlike the composite launchers, this tool has **no double-launch guard**: calling
+it again always issues a new paid launch, even seconds later with identical
+arguments. So when a call returns nothing at all, do not simply retry. Read the
+record back first \u2014 \`leadbay_research_lead_by_id\` or \`leadbay_get_contacts\` for a
+lead, \`leadbay_account_status\` for background work that has since finished \u2014 to
+see whether the launch already landed, and tell the user what you are about to
+spend before spending it again.
+
+
 ## QUOTA, NOT CREDITS
 
 Enrichment is gated by QUOTA (the per-window allowance in \`leadbay_account_status\`), not a credit balance. **Never pre-refuse because a credit number looks low or zero** \u2014 a freemium/fresh account with quota left can enrich even when its credit counter reads 0. The reveal either fits the remaining quota or the backend returns 429 (\`quota_exceeded\`); only THEN surface the exhausted window + wait-or-top-up choice. The \`credits_remaining\` field on the result is **advisory internal context only \u2014 do NOT display it**. Because it can read \`0\` on an account that still has quota, printing \`_(N credits remaining)_\` would falsely tell the user they're out. Do not render a credits balance at all; if the user asks where they stand, call \`leadbay_account_status\` and show the quota gauge instead. The actual per-contact cost (\`enrichment.credits_used\`) appears on the contact after enrichment.
@@ -2342,6 +2423,36 @@ WHEN TO USE: as the agent's go-to enrichment entry point, immediately before pro
 
 WHEN NOT TO USE: to enrich a single named contact \u2014 that's leadbay_enrich_contacts. Speculatively, before the user has committed to outreaching \u2014 enrichment consumes quota. **NOT to add "titles" or "LinkedIn" to a list** \u2014 a contact's \`job_title\` and \`linkedin_page\` already ride on the contact record; they are FREE and need no enrichment. If the user asks for "title and LinkedIn only", read those fields directly (e.g. leadbay_get_contacts / leadbay_research_lead_by_id); do NOT launch a job here. This tool is strictly the email / phone reveal, which consumes quota.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 ## ENRICHMENT CONSUMES QUOTA \u2014 the model to reason with
 
 Each email reveal and each phone reveal **consumes quota** (the per-window daily / weekly / monthly allowance shown in \`leadbay_account_status\`). That is the ONLY thing that gates enrichment. Do **NOT** reason about, mention, or block on "credits": there is no separate credit wall the user must clear first \u2014 enrichment either fits the user's remaining quota or the backend returns 429 (\`{status:'quota_exceeded'}\`) when a window is actually exhausted. **Never pre-refuse enrichment because a credit number looks low or zero** \u2014 a fresh/freemium account with quota still available can enrich even when its credit counter reads 0. If and only if the backend returns \`quota_exceeded\`, tell the user which window is exhausted and offer the wait-or-top-up choice (see \`leadbay_account_status\`).
@@ -2364,7 +2475,7 @@ Do NOT rely on a bare call (no \`confirm\`, no \`dry_run\`, no channels) as a "s
 
 ## AFTER LAUNCH \u2014 STAY ACTIVE UNTIL DONE
 
-When a launch returns \`mode:"launched"\` with a \`bulk_id\`, the enrichment runs ASYNC on the backend \u2014 the tool returns immediately, before any email/phone is attached. **Unless the user explicitly said to start it in the background / not to wait** (e.g. "kick it off, I'll check later", "don't wait for it"), stay active and report in-turn \u2014 do NOT end your turn on the ack, and do NOT say "I'll let you know when it's done." (If the user DID ask you not to wait, honor that: hand back the \`bulk_id\` and a one-line "running \u2014 you can ask any time". Only promise that completion will auto-surface via \`_meta.notifications\` when the launch returned a non-null \`notification_id\`; if \`notification_id\` is null (the nullable-backend path), say instead that you'll re-check when asked / they should ask again later \u2014 nothing surfaces automatically without a notification id. Don't force a poll loop against explicit intent.) In the default (stay-active) case: call \`leadbay_bulk_enrich_status({bulk_id})\` in a loop, re-polling until the job is done (small batches typically finish in under ~2 min). Pass \`include_contacts:true\` on the read you intend to report from, so you get each lead's enriched contacts back. Note that \`include_contacts\` returns each lead's FULL contact list (it fans out through \`leadbay_get_contacts\`), which can include contacts of OTHER roles that were already enriched in earlier runs \u2014 so **filter your report to the \`titles\` you just enriched** (match each contact's \`job_title\` to the requested titles). Don't present a pre-existing CFO/Sales email as part of this CEO/Owner/Manager run. Then \u2014 on your own, without waiting for the user to reprompt \u2014 report the enrichment: which of the just-enriched contacts now have emails / phones, and the counts from \`overall_progress\` (\`done\`/\`total\`). \`leadbay_bulk_enrich_status\` also returns \`bulk_progress.success_count\` / \`failure_count\` / \`quota_hit_count\` on the notification fast path \u2014 use those when present, but the legacy per-lead fallback returns \`overall_progress\` only, so don't assume \`bulk_progress\` exists (see the status tool's COMPLETION REPORT). Then show refreshed quota via \`leadbay_account_status\` (see AFTER above).
+When a launch returns \`mode:"launched"\` with a \`notification_id\`, the enrichment runs ASYNC on the backend \u2014 the tool returns immediately, before any email/phone is attached. **Unless the user explicitly said to start it in the background / not to wait** (e.g. "kick it off, I'll check later", "don't wait for it"), stay active and report in-turn \u2014 do NOT end your turn on the ack, and do NOT say "I'll let you know when it's done." (If the user DID ask you not to wait, honor that: hand back the \`notification_id\` and a one-line "running \u2014 you can ask any time". Only promise that completion will auto-surface via \`_meta.notifications\` when the launch returned a non-null \`notification_id\`; if \`notification_id\` is null (the nullable-backend path), say instead that you'll re-check when asked / they should ask again later \u2014 nothing surfaces automatically without a notification id. Don't force a poll loop against explicit intent.) In the default (stay-active) case: call \`leadbay_bulk_enrich_status({notification_id})\` in a loop, re-polling until the job is done (small batches typically finish in under ~2 min). Pass \`include_contacts:true\` on the read you intend to report from, so you get each lead's enriched contacts back. Note that \`include_contacts\` returns each lead's FULL contact list (it fans out through \`leadbay_get_contacts\`), which can include contacts of OTHER roles that were already enriched in earlier runs \u2014 so **filter your report to the \`titles\` you just enriched** (match each contact's \`job_title\` to the requested titles). Don't present a pre-existing CFO/Sales email as part of this CEO/Owner/Manager run. Then \u2014 on your own, without waiting for the user to reprompt \u2014 report the enrichment: which of the just-enriched contacts now have emails / phones, and the counts from \`overall_progress\` (\`done\`/\`total\`). \`leadbay_bulk_enrich_status\` also returns \`bulk_progress.success_count\` / \`failure_count\` / \`quota_hit_count\` on the notification fast path \u2014 use those when present, but the per-lead path returns \`overall_progress\` only, so don't assume \`bulk_progress\` exists (see the status tool's COMPLETION REPORT). Then show refreshed quota via \`leadbay_account_status\` (see AFTER above).
 
 **"Done" = \`all_done:true\` OR the resolvable work has plateaued.** Keep polling while \`overall_progress.done\` is still climbing. But \`total\` counts every matching contact, and some (unresolvable titles, contacts with no findable email) never flip to done \u2014 so a job can sit below 100% with \`all_done:false\` forever. A plateau is only real once the job has had time to run: do NOT declare it from the first few back-to-back reads (early on \`done\` can sit at its initial value while the backend is still spinning the job up). Give it at least ~90s\u20132 min of actual elapsed polling \u2014 space your polls out (~15\u201330s apart) rather than firing them back-to-back \u2014 and only treat the set as complete when \`overall_progress.done\` has held steady across several spaced polls over that window. Then stop polling and report what resolved, naming the ones that didn't. Key the "didn't resolve" wording off the channels the user actually requested and the returned contact fields (contacts carry \`email\` and \`phone_number\`) \u2014 a contact enriched for phone that came back with no \`phone_number\` is "no phone number found", one with no \`email\` is "no email found", email+phone that got neither is "no contact details found"; if \`quota_hit_count\` is non-zero say those were skipped because the quota window was exhausted. Do NOT hard-label every non-success as "no email found" when phone was requested. Do NOT spin indefinitely waiting for \`all_done\` on contacts the engine won't resolve, and do NOT \`ScheduleWakeup\` / defer the finished list to a later turn \u2014 deliver the resolved results in THIS reply.
 
@@ -3017,9 +3128,39 @@ WHEN TO USE: agent has a list of companies (domains, or CSV-shaped rows from the
 
 WHEN NOT TO USE: discovery (use leadbay_pull_leads); single-lead deep dive (use leadbay_research_lead_by_id); high-cadence or untrusted automation \u2014 this mutates user state and consumes ai_rescore + web_fetch quota.
 
-Budgets: \`total_budget_ms\` caps wall-clock; \`per_lead_budget_ms\` caps each lead's poll. For short transport timeouts, pass \`wait_for_completion:false\` and poll \`leadbay_import_status\`. Outputs \`qualified[]\`, \`still_running[]\`, \`not_imported[]\`, \`qualify_id\` (resumable handle). Idempotent within a 5-min window. \`dry_run:'preview'\` returns mapping hints + custom-field candidates without importing.
+## A launched job cannot be stopped
 
-\`not_imported\` rows with \`reason:"uncrawled"\` are **pending a background crawl**, NOT failures: Leadbay just hasn't matched/crawled that domain yet and will add the lead asynchronously (the label doesn't verify the URL resolves \u2014 don't call the site bad, but don't certify it valid either). Surface them as pending; the leads populate in the user's Leadbay account as the crawl completes (no tool here fetches them on demand \u2014 \`leadbay_import_status\` reports the rows the wizard has already placed, not leads a later crawl adds, and \`leadbay_pull_leads\` reads the active lens's wishlist so an imported lead outside that lens may not appear). To pull those specific companies back through the MCP, re-run the import later. A large \`uncrawled\` share on a fresh list is normal.
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
+Budgets: \`total_budget_ms\` caps wall-clock; \`per_lead_budget_ms\` caps each lead's poll. For short transport timeouts, pass \`wait_for_completion:false\` and poll \`leadbay_import_status\`. Outputs \`qualified[]\`, \`still_running[]\`, \`not_imported[]\`, plus the ids that resume it: \`lead_ids\` + \`lens_id\` for leadbay_qualify_status, \`import_ids\` for leadbay_import_status. There is no qualification \`notification_id\` \u2014 the qualify phase runs per-lead, so no job notification exists; \`notification_ids[]\` are the file-import ones. Idempotent within a 5-min window. \`dry_run:'preview'\` returns mapping hints + custom-field candidates without importing.
+
+\`not_imported\` rows with \`reason:"uncrawled"\` are **pending a background crawl**, NOT failures: Leadbay just hasn't matched/crawled that domain yet and will add the lead asynchronously (the label doesn't verify the URL resolves \u2014 don't call the site bad, but don't certify it valid either). Surface them as pending; the leads populate in the user's Leadbay account as the crawl completes (no tool here fetches them on demand \u2014 \`leadbay_import_status\` returns status/progress only, and \`leadbay_pull_leads\` reads the active lens's wishlist so an imported lead outside that lens may not appear). To pull those specific companies back through the MCP, re-run the import later. A large \`uncrawled\` share on a fresh list is normal.
 
 This tool MUTATES state. The caller (agent or human-in-the-loop) is responsible for confirming intent before invocation; the MCP server does not soft-prompt for confirmation. See \`annotations.destructiveHint\`.
 
@@ -3044,9 +3185,9 @@ Otherwise, partition \`not_imported\` by \`reason\` into these buckets before yo
 **Header \u2014 single line, choose by status:**
 
 - Completed: \`"\u2713 Import complete \u2014 N imported \xB7 P pending crawl \xB7 Q need attention"\` (drop any segment whose count is 0)
-- Running, \`handle_id\` present: \`"\u23F3 Import running \u2014 handle_id <id>; poll leadbay_import_status"\`
-- Running with \`timed_out:true\` (blocking call ran out of poll budget): the import is FINE and still running server-side \u2014 never render this as an error or a failure. \`"\u23F3 Import still running (the backend is slow today) \u2014 I'll check back."\` Then call \`leadbay_import_status({importIds})\`, do NOT re-run leadbay_import_leads. If \`rows_pending_upload\` is present, add \`"\u26A0 K rows weren't submitted \u2014 re-import just those."\`
-- Pending qualification (\`leadbay_import_and_qualify\`): \`"\u2713 Imported N leads \xB7 qualifying M of them \u2014 qualify_id <id>"\`
+- Running: \`"\u23F3 Import running \u2014 importIds <ids>; poll leadbay_import_status"\`
+- Running with \`timed_out:true\` (the blocking call ran out of poll budget): the import is FINE and still running server-side \u2014 never render this as an error or a failure. \`"\u23F3 Import still running (the backend is slow today) \u2014 I'll check back."\` Then call \`leadbay_import_status({importIds})\`, do NOT re-run leadbay_import_leads. If \`rows_pending_upload\` is present, add \`"\u26A0 K rows weren't submitted \u2014 re-import just those."\`
+- Pending qualification (\`leadbay_import_and_qualify\`): \`"\u2713 Imported N leads \xB7 qualifying M of them \u2014 I'll pick it up with leadbay_qualify_status"\` (its resume ids are \`lead_ids\` + \`lens_id\`; there is no qualification notification_id to quote)
 
 Count \`uncrawled\` rows as **pending**, never as failures \u2014 never say "M failed" when the M is mostly/entirely uncrawled rows.
 
@@ -3094,7 +3235,7 @@ User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutual
 
 | Observation                                    | Suggest                                                       | Calls                                                  |
 |------------------------------------------------|---------------------------------------------------------------|--------------------------------------------------------|
-| Status: running, \`handle_id\` present           | "Check progress"                                              | leadbay_import_status(handle_id)                       |
+| Status: running                                | "Check progress"                                              | leadbay_import_status(importIds)                       |
 | Status: running with \`timed_out:true\`          | "Check progress" \u2014 NOT "retry the import"                     | leadbay_import_status(importIds, dry_run if the result carried it) after ~30s; \`result.leads\` carries the leadIds once complete |
 | \`rows_pending_upload\` present                  | "Import the rows that never got submitted"                    | leadbay_import_leads (that subset only)                |
 | Status: complete, imports succeeded            | "Run AI qualification on the imported leads"                  | leadbay_bulk_qualify_leads([leadIds]) \u2014 or use leadbay_import_and_qualify next time |
@@ -3104,9 +3245,9 @@ User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutual
 | User wants to see the imported leads           | "See the imported leads in your view"                         | leadbay_pull_leads                                     |
 | User had follow-up intent for the imports      | "Prep outreach for [a specific imported lead]"                | leadbay_prepare_outreach(leadId)                       |
 `;
-    leadbay_import_leads = `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_by_id. 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 end-to-end import+qualify in one call, prefer leadbay_import_and_qualify. For messy files, prefer the \`leadbay_import_file\` prompt which walks an agent through scan \u2192 resolve \u2192 preserve \u2192 commit phases.
+    leadbay_import_leads = `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_by_id. For MCP clients with short transport timeouts, pass \`wait_for_completion:false\` to return quickly with \`{status:'running', importIds}\`; poll leadbay_import_status with that handle. For end-to-end import+qualify in one call, prefer leadbay_import_and_qualify. For messy files, prefer the \`leadbay_import_file\` prompt which walks an agent through scan \u2192 resolve \u2192 preserve \u2192 commit phases.
 
-SLOW BACKEND \u21D2 \`{status:'running', timed_out:true, importIds}\`. The wizard is sometimes slow; when the poll budget runs out this tool returns that SUCCESS result, not an error. The import is still running server-side. **Do NOT call leadbay_import_leads again** \u2014 that re-uploads the file and leaves a duplicate CRM-imports row. Call \`leadbay_import_status({importIds})\` after ~30s \u2014 and pass \`dry_run:true\` too if the result carried it; on \`complete\` it returns \`result.leads\` with the leadIds, while \`phase:"committing"\` just means keep polling. Tell the user it's running and you'll check back \u2014 it is not a problem to report. Exception: \`rows_pending_upload\` rows never reached the backend and DO need a fresh call for that subset only. In records mode the result also carries \`row_ids\` \u2014 the synthetic id of each input row, in your \`records[]\` order \u2014 because \`leadbay_import_status\` reports recovered leads by that id; keep it to map them back to your source rows.
+SLOW BACKEND \u21D2 \`{status:'running', timed_out:true, importIds}\`. The wizard is sometimes slow; when the poll budget runs out this tool returns that SUCCESS result, not an error. The import is still running server-side. **Do NOT call leadbay_import_leads again** \u2014 that re-uploads the file and leaves a duplicate CRM-imports row. Leadbay has no cancel, so a Cancel or timeout is no reason to call it either. Sole exception: a \`wait_for_completion:false\` call that returned NOTHING \u2014 and even that can re-upload, so check CRM-imports. Call \`leadbay_import_status({importIds})\` after ~30s \u2014 and pass \`dry_run:true\` too if the result carried it; on \`complete\` it returns \`result.leads\` with the leadIds, while \`phase:"committing"\` just means keep polling. Tell the user it's running and you'll check back \u2014 it is not a problem to report. Exception: \`rows_pending_upload\` rows never reached the backend and DO need a fresh call for that subset only. In records mode the result also carries \`row_ids\` \u2014 the synthetic id of each input row, in your \`records[]\` order \u2014 because \`leadbay_import_status\` reports recovered leads by that id; keep it to map them back to your source rows.
 
 TWO MODES: (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. (B) Custom records + mapping \u2014 pass \`records: [{Col1, Col2, ...}]\` plus \`mappings.fields: {Col1: 'LEAD_NAME', ...}\`. \`mappings.fields\` must include LEADBAY_ID, CRM_ID, SIREN, LEAD_NAME, or LEAD_WEBSITE (resolver needs at least one identity key). Pass exactly one of \`domains\` / \`records\`. Reserved column \`MCP_ROW_ID\` cannot appear in records/mappings \u2014 the tool injects it for stable reconciliation.
 
@@ -3141,9 +3282,9 @@ Otherwise, partition \`not_imported\` by \`reason\` into these buckets before yo
 **Header \u2014 single line, choose by status:**
 
 - Completed: \`"\u2713 Import complete \u2014 N imported \xB7 P pending crawl \xB7 Q need attention"\` (drop any segment whose count is 0)
-- Running, \`handle_id\` present: \`"\u23F3 Import running \u2014 handle_id <id>; poll leadbay_import_status"\`
-- Running with \`timed_out:true\` (blocking call ran out of poll budget): the import is FINE and still running server-side \u2014 never render this as an error or a failure. \`"\u23F3 Import still running (the backend is slow today) \u2014 I'll check back."\` Then call \`leadbay_import_status({importIds})\`, do NOT re-run leadbay_import_leads. If \`rows_pending_upload\` is present, add \`"\u26A0 K rows weren't submitted \u2014 re-import just those."\`
-- Pending qualification (\`leadbay_import_and_qualify\`): \`"\u2713 Imported N leads \xB7 qualifying M of them \u2014 qualify_id <id>"\`
+- Running: \`"\u23F3 Import running \u2014 importIds <ids>; poll leadbay_import_status"\`
+- Running with \`timed_out:true\` (the blocking call ran out of poll budget): the import is FINE and still running server-side \u2014 never render this as an error or a failure. \`"\u23F3 Import still running (the backend is slow today) \u2014 I'll check back."\` Then call \`leadbay_import_status({importIds})\`, do NOT re-run leadbay_import_leads. If \`rows_pending_upload\` is present, add \`"\u26A0 K rows weren't submitted \u2014 re-import just those."\`
+- Pending qualification (\`leadbay_import_and_qualify\`): \`"\u2713 Imported N leads \xB7 qualifying M of them \u2014 I'll pick it up with leadbay_qualify_status"\` (its resume ids are \`lead_ids\` + \`lens_id\`; there is no qualification notification_id to quote)
 
 Count \`uncrawled\` rows as **pending**, never as failures \u2014 never say "M failed" when the M is mostly/entirely uncrawled rows.
 
@@ -3191,7 +3332,7 @@ User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutual
 
 | Observation                                    | Suggest                                                       | Calls                                                  |
 |------------------------------------------------|---------------------------------------------------------------|--------------------------------------------------------|
-| Status: running, \`handle_id\` present           | "Check progress"                                              | leadbay_import_status(handle_id)                       |
+| Status: running                                | "Check progress"                                              | leadbay_import_status(importIds)                       |
 | Status: running with \`timed_out:true\`          | "Check progress" \u2014 NOT "retry the import"                     | leadbay_import_status(importIds, dry_run if the result carried it) after ~30s; \`result.leads\` carries the leadIds once complete |
 | \`rows_pending_upload\` present                  | "Import the rows that never got submitted"                    | leadbay_import_leads (that subset only)                |
 | Status: complete, imports succeeded            | "Run AI qualification on the imported leads"                  | leadbay_bulk_qualify_leads([leadIds]) \u2014 or use leadbay_import_and_qualify next time |
@@ -3201,11 +3342,45 @@ User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutual
 | User wants to see the imported leads           | "See the imported leads in your view"                         | leadbay_pull_leads                                     |
 | User had follow-up intent for the imports      | "Prep outreach for [a specific imported lead]"                | leadbay_prepare_outreach(leadId)                       |
 `;
-    leadbay_import_status = `Retrieve the current **status/progress** of a lead import, and its leadIds once it finishes. Pass \`handle_id\` \u2014 returned by either \`leadbay_import_leads\` OR \`leadbay_import_and_qualify\` when called with \`wait_for_completion:false\` \u2014 to resolve the stored result (leads + not_imported) for that async run. Pass \`importIds[]\` when you don't have a handle: after a blocking \`leadbay_import_leads\` returned \`{status:'running', timed_out:true, importIds}\`, or from any completed import's \`importIds\` (\`leadbay_import_and_qualify\` calls the same field \`import_ids\`). **Both paths return leads.** The \`importIds[]\` path reads the wizard's records directly, so once every named import is \`complete\` (and it wasn't a dry run) the response carries \`result.leads\` + \`result.not_imported\` \u2014 that is how you recover the leadIds from an import that timed out mid-poll, without re-importing. \`result.still_settling\` counts rows the wizard hasn't finished placing; they are neither imported nor failed, so poll again rather than reporting them. If \`result\` is absent on a \`complete\` import the records weren't readable \u2014 report completion without inventing counts. \`phase:"committing"\` means the import is still being committed, NOT that it finished with nothing: keep polling. Pass \`dry_run:true\` when the importIds came from a dry run (a \`{timed_out:true}\` result carries \`dry_run\` \u2014 hand it straight back); a finished dry run and an import mid-commit are identical on the wire, so without that flag this tool reports \`committing\` rather than risk rendering a validation pass as a real import. This status call performs a single refresh pass and never polls in a loop.
+    leadbay_import_status = `Retrieve the current **status/progress** of a lead import, and its leadIds once it finishes. Pass the \`importIds\` the launch returned \u2014 \`leadbay_import_leads\` returns \`importIds\`, \`leadbay_import_and_qualify\` returns \`import_ids\`. These are the backend's own import ids, so they resolve from a later message, a later conversation, or the next day; nothing is stored on the MCP side. Also pass the \`dry_run\` the import was launched with, so completion is judged against the right phase (a dry run finishes at preprocess, a real import at processing). This status call performs a single refresh pass and never polls in a loop.
+
+WHEN TO USE: after an async import returns its ids \u2014 \`leadbay_import_leads\` as \`{status:'running', importIds}\`, \`leadbay_import_and_qualify\` as \`import_ids\` \u2014 poll with those; OR to check whether a finished import is still processing. This tool does NOT surface the leads Leadbay adds later for pending-crawl (\`uncrawled\`) rows \u2014 those populate in the user's Leadbay account as the crawl completes; no tool here fetches them on demand (re-run the import to pull them back through the MCP).
+
+WHEN NOT TO USE: for the qualification half \u2014 use leadbay_qualify_status, with the \`lead_ids\` + \`lens_id\` an \`leadbay_import_and_qualify\` launch returned (it has no qualification \`notification_id\`; its \`notification_ids[]\` are these same file imports); or when you still want the legacy blocking behavior from leadbay_import_leads with \`wait_for_completion=true\`.
+
+## A launched job cannot be stopped
 
-WHEN TO USE: after an async import (\`leadbay_import_leads\` OR \`leadbay_import_and_qualify\` with \`wait_for_completion:false\`) returns \`{status:'running', handle_id}\`, poll with that \`handle_id\`; OR to check whether a finished import is still processing. This tool does NOT surface the leads Leadbay adds later for pending-crawl (\`uncrawled\`) rows \u2014 those populate in the user's Leadbay account as the crawl completes; no tool here fetches them on demand (re-run the import to pull them back through the MCP).
+Leadbay has no cancel. A job started by \`leadbay_enrich_titles\`,
+\`leadbay_bulk_qualify_leads\`, \`leadbay_import_leads\` or
+\`leadbay_import_and_qualify\` runs to completion on Leadbay. The user cancelling
+in the chat, a request timeout, or a closed stream stops YOUR waiting, never the
+job, and \`cancelled: true\` on an earlier result means we stopped watching, not
+that the work stopped.
+
+**This tool only reads.** Calling it again launches nothing and spends no quota,
+so poll it as often as the job needs \u2014 a timeout here is a reason to call it
+again, not a reason to stop.
+
+One import state does NOT progress: a chunk cancelled before its mappings were
+committed reads \`running\` / \`committing\` forever. If the counts hold flat across
+several spaced polls, say so and stop, rather than polling on.
+
+What must not be repeated is the LAUNCH \u2014 for work that actually launched. Re-run
+a launcher only for a subset that never started, never for the whole batch:
+
+- \`failed[]\` entries with \`error:"not_queued"\`;
+- a \`rows_pending_upload\` count;
+- leads in \`still_running\` after a CANCELLED \`leadbay_import_and_qualify\`. Its
+  fan-out is sequential, so an interruption leaves the remainder unlaunched and
+  folds them in with the ones that did launch. Nothing in the result tells the
+  two apart, and this tool cannot start either. Wait until the REST of the batch
+  has settled: what launched settles in order, so leads still unanswered after
+  that are the ones that never started. Only then call
+  \`leadbay_bulk_qualify_leads({leadIds, lensId})\` for exactly those ids. A lead
+  that is merely slow looks identical to one that never launched over a few
+  polls, and re-launching it charges the user twice \u2014 when unsure, tell the user
+  rather than guess.
 
-WHEN 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\`.
 
 ---
 
@@ -3225,12 +3400,11 @@ After the status line, propose the obvious refresh / progress-check / recovery a
 
 Specifically for import status:
 
-This tool returns \`status\`, \`importIds\`, and \`progress\` ({phase, records_processed, records_total}). It carries a \`result\` object (with \`leads\` + \`not_imported\`) when resolving an async \`handle_id\` whose run completed in this MCP instance, AND on the \`importIds[]\` path once every named import is \`complete\` and it wasn't a dry run. A \`complete\` import with no \`result\` means the records weren't readable \u2014 render completion only. **Render only from the fields actually present; never invent counts.**
+This tool returns \`status\`, \`importIds\`, and \`progress\` ({phase, records_processed, records_total}). Once every named import is \`complete\` and it wasn't a dry run, it also reconciles the wizard's records and carries \`result\` ({leads, not_imported, importIds, still_settling?}) \u2014 that is how you recover the leadIds of an import you stopped watching, without re-importing. \`result.still_settling\` counts rows the wizard hasn't finished placing; they are neither imported nor failed, so poll again rather than reporting them. If \`result\` is absent on a \`complete\` import the records weren't readable \u2014 report completion without inventing counts. **Render only from the fields actually present; never invent counts.**
 
 Caveat on \`progress\`: \`records_processed\` counts only the rows that MATCHED an existing lead (backend \`imported_records\`), not every row that finished processing \u2014 so for a complete import whose rows are mostly/all \`uncrawled\` (pending crawl), \`records_processed\` is legitimately low or 0. Never read a low \`records_processed\` on a \`complete\` import as "stuck" or "failed": once \`status:"complete"\`, processing is done; the pending-crawl rows just matched no existing lead yet.
 
-- Running \u2192 \`"\u23F3 Import still running \u2014 phase <phase>; check back in ~M minutes."\` (use the phase; don't turn the matched-count into an "X/Y processed" progress bar). \`phase:"committing"\` is normal for an import that timed out \u2014 say it's still being committed, never that it failed or finished empty.
-- Complete with **\`dry_run:true\`** on the response \u2192 a VALIDATION pass; nothing was committed. \`"\u{1F50E} Dry run complete \u2014 input validated, nothing imported. Re-run without dry_run to commit."\` Never render this as a completed import, and never quote a lead count.
+- Running \u2192 \`"\u23F3 Import still running \u2014 phase <phase>; check back in ~M minutes."\` (use the phase; don't turn the matched-count into an "X/Y processed" progress bar). \`phase:"committing"\` means the mappings are still being committed \u2014 say it's still being committed, never that it failed or finished empty.
 - Complete, **no \`result\`** \u2192 \`"\u2713 Import complete."\` Do NOT append a \`records_processed/records_total\` fraction (it undercounts pending-crawl rows and looks stuck) and do NOT report pending-crawl / need-attention bucket counts \u2014 the row-level \`not_imported\` breakdown isn't in this response.
 - Complete with \`result.still_settling > 0\` \u2192 say \`"\u2713 Import complete \u2014 N imported, S rows still being placed."\` Never count \`still_settling\` rows as failures.
 - Complete, **\`result\` present AND it was a dry run** (\`result.dry_run:true\`, or every \`result.not_imported\` row has \`reason:"dry_run"\`) \u2192 this resolved handle was a VALIDATION pass, nothing committed. Render \`"\u{1F50E} Dry run complete \u2014 V rows validated, nothing imported. Re-run without dry_run to commit."\` \u2014 do NOT render it as a real import completion or use the pending/attention buckets.
@@ -3262,12 +3436,29 @@ How the OTHER reasons map to the "Need attention" bucket (see the render block a
 | Status: running (incl. \`committing\`) | "Check again in N minutes"                           | leadbay_import_status \u2014 re-call (pass \`dry_run:true\` if the ids came from a dry run) |
 | Status: error / failed (true error)  | "Diagnose the failure"                               | leadbay_resolve_import_rows    |
 `;
-    leadbay_launch_bulk_enrichment = `Launch a bulk-enrichment job against the current selection. The backend requires \`email=true\` OR \`phone=true\` (both can be true). Returns 204 with no body \u2014 there is no bulk_id and no per-job status endpoint. Track results by polling individual leads via leadbay_get_contacts after ~60s; a contact is done for this run only when the REQUESTED channel landed (requested \`email\` and/or \`phone_number\` present), not \`contact.enrichment.done\` alone (that flag is already true for a contact enriched on the other channel earlier). \`dry_run:true\` returns the call shape without contacting the backend.
+    leadbay_launch_bulk_enrichment = `Launch a bulk-enrichment job against the current selection. The backend requires \`email=true\` OR \`phone=true\` (both can be true). Returns 204 with no body \u2014 there is no notification_id and no per-job status endpoint. Track results by polling individual leads via leadbay_get_contacts after ~60s; a contact is done for this run only when the REQUESTED channel landed (requested \`email\` and/or \`phone_number\` present), not \`contact.enrichment.done\` alone (that flag is already true for a contact enriched on the other channel earlier). \`dry_run:true\` returns the call shape without contacting the backend.
 
 WHEN TO USE: low-level.
 
 WHEN NOT TO USE: from agent flow \u2014 leadbay_enrich_titles handles selection lifecycle, preview, launch, and cleanup.
 
+## A launched job cannot be stopped, and this tool has no retry guard
+
+Leadbay has no cancel. Once this call returns having actually launched, the work
+is queued on Leadbay and runs to completion, and the quota it costs is already
+committed. A \`dry_run\` result reached no backend and spent nothing. The user
+cancelling in the chat, a request timeout, or a closed stream stops YOUR waiting,
+never the job.
+
+Unlike the composite launchers, this tool has **no double-launch guard**: calling
+it again always issues a new paid launch, even seconds later with identical
+arguments. So when a call returns nothing at all, do not simply retry. Read the
+record back first \u2014 \`leadbay_research_lead_by_id\` or \`leadbay_get_contacts\` for a
+lead, \`leadbay_account_status\` for background work that has since finished \u2014 to
+see whether the launch already landed, and tell the user what you are about to
+spend before spending it again.
+
+
 This tool MUTATES state. The caller (agent or human-in-the-loop) is responsible for confirming intent before invocation; the MCP server does not soft-prompt for confirmation. See \`annotations.destructiveHint\`.
 `;
     leadbay_like_lead = `## WHEN TO USE
@@ -4337,13 +4528,70 @@ WHEN TO USE: low-level \u2014 when you need to kick qualification on exactly one
 
 WHEN NOT TO USE: as the agent's bulk-qualify path \u2014 use leadbay_bulk_qualify_leads, which paginates past already-qualified leads, fans out, polls, and bails out cleanly on 429.
 
+## A launched job cannot be stopped, and this tool has no retry guard
+
+Leadbay has no cancel. Once this call returns having actually launched, the work
+is queued on Leadbay and runs to completion, and the quota it costs is already
+committed. A \`dry_run\` result reached no backend and spent nothing. The user
+cancelling in the chat, a request timeout, or a closed stream stops YOUR waiting,
+never the job.
+
+Unlike the composite launchers, this tool has **no double-launch guard**: calling
+it again always issues a new paid launch, even seconds later with identical
+arguments. So when a call returns nothing at all, do not simply retry. Read the
+record back first \u2014 \`leadbay_research_lead_by_id\` or \`leadbay_get_contacts\` for a
+lead, \`leadbay_account_status\` for background work that has since finished \u2014 to
+see whether the launch already landed, and tell the user what you are about to
+spend before spending it again.
+
+
 This tool MUTATES state. The caller (agent or human-in-the-loop) is responsible for confirming intent before invocation; the MCP server does not soft-prompt for confirmation. See \`annotations.destructiveHint\`.
 `;
-    leadbay_qualify_status = `Retrieve the current state of an import_and_qualify (or bulk_qualify_leads) 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.
+    leadbay_qualify_status = `Retrieve the current state of a bulk_qualify_leads or import_and_qualify launch. Which ids to pass depends on which tool launched it, because only one of them creates a qualification job on the backend:
 
-WHEN TO USE: after leadbay_import_and_qualify or leadbay_bulk_qualify_leads 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.
+- **\`leadbay_bulk_qualify_leads\`** returns a \`notification_id\`. Pass it for progress in ONE call, and add the \`lead_ids\` + \`lens_id\` it also returned for per-lead detail (which settled, which are still running).
+- **\`leadbay_import_and_qualify\`** returns NO qualification \`notification_id\` \u2014 its qualify phase runs per-lead, so no job notification exists. Pass the \`lead_ids\` + \`lens_id\` it returned. Its \`notification_ids[]\` are the FILE-IMPORT notifications; handing one of those to this tool is rejected as the wrong kind, and \`leadbay_import_status({importIds})\` is where the import half is polled.
+
+**When it is finished:** \`status\` is always \`"launched"\` \u2014 it is not a progress field. On the \`notification_id\` path the job is done when \`in_progress\` is false (or \`bulk_progress.success_count + failure_count\` reaches \`total_count\`); \`still_running[]\` is empty on that path from the very first poll and must NOT be read as "done". On the \`lead_ids\` path the job is done when \`still_running[]\` is empty. Pass both and you get both signals in one call.
+
+Everything comes straight out of the launch response \u2014 nothing is stored on the MCP side. A backend job is scoped to the user who launched it, so a \`notification_id\` resolves from a later message, a later conversation, or the next day.
+
+WHEN TO USE: after leadbay_bulk_qualify_leads or leadbay_import_and_qualify came back with a non-empty \`still_running[]\`, call this tool a few minutes later (or hours) with those ids to retrieve the now-completed qualifications without re-running the import or re-spending qualify quota.
 
 WHEN NOT TO USE: as a substitute for leadbay_research_lead_by_id \u2014 that's a deeper per-lead profile and includes contacts. This tool is purely the qualification answers + signals_count.
+
+## A launched job cannot be stopped
+
+Leadbay has no cancel. A job started by \`leadbay_enrich_titles\`,
+\`leadbay_bulk_qualify_leads\`, \`leadbay_import_leads\` or
+\`leadbay_import_and_qualify\` runs to completion on Leadbay. The user cancelling
+in the chat, a request timeout, or a closed stream stops YOUR waiting, never the
+job, and \`cancelled: true\` on an earlier result means we stopped watching, not
+that the work stopped.
+
+**This tool only reads.** Calling it again launches nothing and spends no quota,
+so poll it as often as the job needs \u2014 a timeout here is a reason to call it
+again, not a reason to stop.
+
+One import state does NOT progress: a chunk cancelled before its mappings were
+committed reads \`running\` / \`committing\` forever. If the counts hold flat across
+several spaced polls, say so and stop, rather than polling on.
+
+What must not be repeated is the LAUNCH \u2014 for work that actually launched. Re-run
+a launcher only for a subset that never started, never for the whole batch:
+
+- \`failed[]\` entries with \`error:"not_queued"\`;
+- a \`rows_pending_upload\` count;
+- leads in \`still_running\` after a CANCELLED \`leadbay_import_and_qualify\`. Its
+  fan-out is sequential, so an interruption leaves the remainder unlaunched and
+  folds them in with the ones that did launch. Nothing in the result tells the
+  two apart, and this tool cannot start either. Wait until the REST of the batch
+  has settled: what launched settles in order, so leads still unanswered after
+  that are the ones that never started. Only then call
+  \`leadbay_bulk_qualify_leads({leadIds, lensId})\` for exactly those ids. A lead
+  that is merely slow looks identical to one that never launched over a few
+  polls, and re-launching it charges the user twice \u2014 when unsure, tell the user
+  rather than guess.
 `;
     leadbay_recall_ordered_titles = `Show job titles the org has previously enriched, so the agent can repeat the same titles for new leads (or skip already-saturated ones). Two implementation paths: (1) PREFERRED \u2014 a selection-scoped preview call that reads \`previously_enriched_titles\` from the backend (newer prod field). (2) FALLBACK \u2014 live aggregation across each lead's enriched contacts. The composite picks transparently.
 
@@ -5939,7 +6187,7 @@ Some Leadbay tool responses include a \`_meta.notifications\` array listing **ba
   - \`leadbay_qualify_status\` \u2192 \`still_running\` is empty: every launched lead has finished or failed. (\`in_progress\` also reads \`false\` on the fast path, but it can be \`null\` on the legacy/fallback read \u2014 so treat an empty \`still_running\` as terminal on its own; only require \`in_progress:false\` when that field is actually present.) LIKE imports, large qualification runs are async by design: \`leadbay_bulk_qualify_leads\` defaults to \`wait_for_completion:false\` for \`count > 5\` or chained workflows because blocking can time out, and \`leadbay_qualify_status\` may take minutes/hours. So don't force a long polling loop on a big run \u2014 return the handle/progress and let completion arrive via \`_meta.notifications\` \u2014 UNLESS the user explicitly asked to wait, or it's a small run that finishes quickly. A small \`wait_for_completion:true\` run you can poll to \`still_running\` empty inline.
   - \`leadbay_import_status\` \u2192 \`status:"complete"\` (or \`"failed"\`). BUT imports are the exception to the stay-active loop: a large \`leadbay_import_leads({wait_for_completion:false})\` is meant to return a handle and resolve over minutes, and the tool does ONE refresh pass per call. Don't block the conversation looping on it \u2014 surface the returned progress/handle and let the completion arrive via \`_meta.notifications\` \u2014 UNLESS the user explicitly asked you to wait for the import, or it's a small import that finishes quickly.
 
-  Enrichment polls to completion in-turn BY DEFAULT \u2014 the exception is when the user explicitly said to start it in the background / not wait ("kick it off, I'll check later"), in which case hand back the bulk_id and let completion arrive via \`_meta.notifications\` (only when a notification id exists; if none was returned, tell the user to ask again / that you'll poll later, since nothing will auto-surface). For qualification and imports, poll inline only for small/quick runs or when the user explicitly asked you to wait; otherwise return the handle and let \`_meta.notifications\` deliver it. Either way, the user should never have to ask "is it done yet?" for work you kicked off in the same turn \u2014 you either report it or hand back a clear in-progress handle.
+  Enrichment polls to completion in-turn BY DEFAULT \u2014 the exception is when the user explicitly said to start it in the background / not wait ("kick it off, I'll check later"), in which case hand back the notification_id and let completion arrive via \`_meta.notifications\` (only when a notification id exists; if none was returned, tell the user to ask again / that you'll poll later, since nothing will auto-surface). For qualification and imports, poll inline only for small/quick runs or when the user explicitly asked you to wait; otherwise return the handle and let \`_meta.notifications\` deliver it. Either way, the user should never have to ask "is it done yet?" for work you kicked off in the same turn \u2014 you either report it or hand back a clear in-progress handle.
 
 Also surfaced as a top-level \`notifications\` array on \`leadbay_account_status\` \u2014 same shape, same handling.
 
@@ -6852,7 +7100,9 @@ var init_qualify_lead = __esm({
         title: "Qualify a single lead",
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        // No double-launch guard: this POSTs straight through, so an identical
+        // repeat is a second paid launch, not a no-op (product#4039).
+        idempotentHint: false,
         openWorldHint: true
       },
       description: leadbay_qualify_lead,
@@ -6928,7 +7178,9 @@ var init_enrich_contacts = __esm({
         title: "Enrich contacts for a lead",
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        // No double-launch guard: this POSTs straight through, so an identical
+        // repeat is a second paid launch, not a no-op (product#4039).
+        idempotentHint: false,
         openWorldHint: true
       },
       description: leadbay_enrich_contacts,
@@ -9012,6 +9264,74 @@ var init_qualify_helpers = __esm({
   }
 });
 
+// ../core/dist/jobs/launch-guard.js
+import { createHash as createHash2 } from "crypto";
+function launchFingerprint(parts) {
+  const flat = parts.map((p) => Array.isArray(p) ? [...p].sort().join(",") : String(p)).join("|");
+  return createHash2("sha256").update(flat).digest("hex");
+}
+function sweep(now) {
+  for (const [k, v] of recent) {
+    if (now - v.at >= WINDOW_MS)
+      recent.delete(k);
+  }
+}
+function beginLaunch(fingerprint, now = Date.now()) {
+  const prior = recallLaunch(fingerprint, now);
+  if (prior) {
+    return prior.in_flight ? { state: "in_flight", seconds_since: prior.seconds_since } : { state: "settled", record: prior };
+  }
+  recent.set(fingerprint, {
+    notification_id: null,
+    in_flight: true,
+    launched_at: new Date(now).toISOString(),
+    at: now
+  });
+  return { state: "owned" };
+}
+function abandonLaunch(fingerprint) {
+  const held = recent.get(fingerprint);
+  if (held?.in_flight)
+    recent.delete(fingerprint);
+}
+function recallLaunch(fingerprint, now = Date.now()) {
+  sweep(now);
+  const hit = recent.get(fingerprint);
+  if (!hit)
+    return void 0;
+  return { ...hit, seconds_since: Math.round((now - hit.at) / 1e3) };
+}
+function rememberLaunch(fingerprint, notificationId, now = Date.now(), importIds) {
+  sweep(now);
+  while (recent.size >= MAX_ENTRIES) {
+    const oldest = recent.keys().next();
+    if (oldest.done)
+      break;
+    recent.delete(oldest.value);
+  }
+  const rec = {
+    notification_id: notificationId,
+    in_flight: false,
+    ...importIds ? { import_ids: importIds } : {},
+    launched_at: new Date(now).toISOString(),
+    at: now
+  };
+  recent.set(fingerprint, rec);
+  return rec;
+}
+function resetLaunchGuard() {
+  recent.clear();
+}
+var WINDOW_MS, MAX_ENTRIES, recent;
+var init_launch_guard = __esm({
+  "../core/dist/jobs/launch-guard.js"() {
+    "use strict";
+    WINDOW_MS = 5 * 60 * 1e3;
+    MAX_ENTRIES = 1e3;
+    recent = /* @__PURE__ */ new Map();
+  }
+});
+
 // ../core/dist/composite/_import-records.js
 function normalizeDomain(input) {
   if (!input || typeof input !== "string")
@@ -9215,7 +9535,7 @@ var init_import_records = __esm({
 
 // ../core/dist/composite/_import-commit-log.js
 function recordCommitFailure(importId, reason) {
-  if (failures.size >= MAX_ENTRIES) {
+  if (failures.size >= MAX_ENTRIES2) {
     const oldest = failures.keys().next().value;
     if (oldest !== void 0)
       failures.delete(oldest);
@@ -9230,17 +9550,17 @@ function commitFailureFor(importIds) {
   }
   return void 0;
 }
-var MAX_ENTRIES, failures;
+var MAX_ENTRIES2, failures;
 var init_import_commit_log = __esm({
   "../core/dist/composite/_import-commit-log.js"() {
     "use strict";
-    MAX_ENTRIES = 500;
+    MAX_ENTRIES2 = 500;
     failures = /* @__PURE__ */ new Map();
   }
 });
 
 // ../core/dist/composite/import-leads.js
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash3, randomUUID } from "crypto";
 function isImportLeadsRunningResult(result) {
   return "status" in result && result.status === "running";
 }
@@ -9302,7 +9622,7 @@ function importFingerprint(params, prep) {
     mappings: prep.mappings,
     dry_run: Boolean(params.dry_run)
   };
-  return createHash2("sha256").update(stableStringify(payload)).digest("hex");
+  return createHash3("sha256").update(stableStringify(payload)).digest("hex");
 }
 function checkAborted(signal) {
   if (signal?.aborted) {
@@ -9677,7 +9997,7 @@ async function commitMappings(client, importId, mappings, ctx) {
     throw err;
   }
 }
-async function completeUploadedChunk(client, upload, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onNotificationId) {
+async function completeUploadedChunk(client, upload, mappings, dryRun, perPhaseBudgetMs, totalDeadline, ctx, signal, onNotificationId, onCommitSent) {
   const { importId, chunk } = upload;
   const phaseBudget = Math.min(perPhaseBudgetMs, Math.max(1, totalDeadline - Date.now()));
   await pollPreprocess(client, importId, phaseBudget, ctx, signal);
@@ -9686,6 +10006,7 @@ async function completeUploadedChunk(client, upload, mappings, dryRun, perPhaseB
     return { importId, records: [], notification_id: null };
   }
   const importNotificationId = await commitMappings(client, importId, mappings, ctx);
+  onCommitSent?.();
   if (importNotificationId) {
     onNotificationId?.(importNotificationId);
     ctx?.logger?.info?.(`import-leads: notification_id=${importNotificationId} importId=${importId}`);
@@ -9851,27 +10172,24 @@ function resumeParkedUpload(client, upload, mappings, ctx) {
     });
   }, 0);
 }
-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(() => {
-  });
+async function runImportInBackground(client, prep, uploadedChunks, opts, ctx) {
   setTimeout(() => {
     void (async () => {
-      const bgCtx = { logger: ctx.logger, bulkTracker: tracker };
+      const bgCtx = { logger: ctx.logger };
       const importIds = uploadedChunks.map((chunk) => chunk.importId);
       const notificationIds = [];
       const matched = /* @__PURE__ */ new Map();
       const notImported = /* @__PURE__ */ new Map();
+      let inFlight = 0;
+      let committed = false;
       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);
+        for (inFlight = 0; inFlight < uploadedChunks.length; inFlight++) {
+          const upload = uploadedChunks[inFlight];
+          committed = false;
+          const out = await completeUploadedChunk(client, upload, prep.mappings, opts.dryRun, opts.perPhaseBudget, totalDeadline, bgCtx, void 0, void 0, () => {
+            committed = true;
+          });
           if (out.notification_id && !notificationIds.includes(out.notification_id)) {
             notificationIds.push(out.notification_id);
           }
@@ -9879,22 +10197,28 @@ async function runImportInBackground(client, prep, uploadedChunks, opts, ctx, ha
             reconcileOneChunk(prep, out, matched, notImported);
           }
         }
-        const result = buildImportLeadsResult(client, prep, importIds, matched, notImported, opts.dryRun, false, notificationIds);
-        await tracker.markImportComplete(handleId, {
-          leads: result.leads,
-          not_imported: result.not_imported,
-          importIds: result.importIds
-        });
+        buildImportLeadsResult(client, prep, importIds, matched, notImported, opts.dryRun, false, notificationIds);
       } catch (err) {
-        await tracker.markImportFailed(handleId, err?.message ?? err?.code ?? "unknown");
+        if (!opts.dryRun) {
+          const parkedFrom = committed ? inFlight + 1 : inFlight;
+          for (const parked of uploadedChunks.slice(parkedFrom)) {
+            resumeParkedUpload(client, parked, prep.mappings, bgCtx);
+          }
+        }
+        ctx?.logger?.warn?.(`import-leads: background import failed for ${importIds.join(",")}: ${err?.message ?? err?.code ?? err}`);
       }
-    })();
+    })().catch((e) => (
+      // Terminal guard. Nothing may escape a detached task — an unhandled
+      // rejection would take the whole multi-tenant hosted process down.
+      ctx?.logger?.error?.(`import-leads: background import crashed: ${e?.message ?? e}`)
+    ));
   }, 0);
 }
 var CHUNK_SIZE, POLL_INTERVAL_MS2, DEFAULT_PER_PHASE_BUDGET_MS, DEFAULT_TOTAL_BUDGET_MS, STABILIZATION_POLLS, MAX_COLUMN_NAME_LEN, RESERVED_COLUMN_RE, CUSTOM_FIELD_RE, IMPORT_RESOLVER_FIELDS, ImportPhaseTimeout, LEAD_STATUSES, LEAD_STATUS_SET, importLeads, DEFAULT_RESUME_COMMIT_BUDGET_MS, resumeCommitBudgetMs;
 var init_import_leads = __esm({
   "../core/dist/composite/import-leads.js"() {
     "use strict";
+    init_launch_guard();
     init_tool_descriptions_generated();
     init_import_records();
     init_import_commit_log();
@@ -10017,7 +10341,7 @@ var init_import_leads = __esm({
           },
           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."
+            description: "When false, upload the rows and return `{status:'running', importIds}` immediately. Poll leadbay_import_status({importIds, dry_run}) \u2014 those importIds are the backend's own and keep working from any conversation. Default is true."
           }
         },
         // Neither field is "required" at the schema level; xor + presence is
@@ -10036,10 +10360,6 @@ var init_import_leads = __esm({
             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. Only on the wait_for_completion=false path; absent when a blocking call timed out (use importIds then)."
-          },
           timed_out: {
             type: "boolean",
             description: "True when a blocking call ran out of poll budget. The import is still running server-side \u2014 poll leadbay_import_status(importIds). Do NOT re-issue the import."
@@ -10070,7 +10390,7 @@ var init_import_leads = __esm({
           region: { type: "string" },
           cancelled: {
             type: "boolean",
-            description: "True when ctx.signal aborted the call mid-flight."
+            description: "True when the HOST cancelled the call (a user Cancel, or the host's own request timeout); a Leadbay-side or phase-budget timeout reports `timed_out` instead. Rows already uploaded keep importing on Leadbay \u2014 poll leadbay_import_status with importIds, but a chunk cancelled before its mappings were committed can read `running` without ever progressing; if the counts stop moving, say so rather than polling on. Rows past the interruption may never have been uploaded; re-run the import for those rows only."
           },
           dry_run: {
             type: "boolean",
@@ -10138,62 +10458,72 @@ var init_import_leads = __esm({
         }
         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, {
+          const fingerprint = launchFingerprint([
+            "import",
+            prep.mode,
+            dryRun,
+            // Cached /users/me — the admin gate above already read it, so this
+            // costs no round trip. Scopes the fingerprint to the organization.
+            await client.resolveOrgId(),
+            importFingerprint(params, prep)
+          ]);
+          const claim = beginLaunch(fingerprint);
+          if (claim.state === "in_flight") {
+            throw client.makeError("IMPORT_LAUNCH_IN_FLIGHT", `An identical import was started ${claim.seconds_since}s ago and has not returned its import ids yet`, "Nothing was uploaded twice. Call leadbay_import_leads again with the same arguments in a few seconds to receive the importIds.", "");
+          }
+          const already = claim.state === "settled" ? claim.record : void 0;
+          if (already) {
+            return {
+              status: "running",
+              importIds: already.import_ids ?? [],
+              notification_ids: [],
+              progress: {
                 phase: "preprocess",
                 records_processed: 0,
                 records_total: prep.validInputs.length
+              },
+              region: client.region,
+              reused: true,
+              seconds_since_original: already.seconds_since,
+              _meta: client.lastMeta ?? {
+                region: client.region,
+                endpoint: "POST /imports",
+                latency_ms: null,
+                retry_after: null
+              }
+            };
+          }
+          const importIds2 = [];
+          const uploadedChunks = [];
+          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);
               });
-            } catch (err) {
-              await ctx.bulkTracker.markImportFailed(reservation.record.bulk_id, err?.message ?? err?.code ?? "unknown");
-              throw err;
+              uploadedChunks.push(upload);
             }
+          } catch (err) {
+            abandonLaunch(fingerprint);
+            throw err;
           }
+          rememberLaunch(fingerprint, null, void 0, importIds2);
           if (uploadedChunks.length > 0) {
-            void runImportInBackground(client, prep, uploadedChunks, {
-              dryRun,
-              perPhaseBudget,
-              totalBudget
-            }, ctx, reservation.record.bulk_id);
+            void runImportInBackground(client, prep, uploadedChunks, { dryRun, perPhaseBudget, totalBudget }, ctx ?? {});
           }
           return {
             status: "running",
-            handle_id: reservation.record.bulk_id,
             importIds: importIds2,
-            // Notifications fire from update_mappings, which the background
-            // task hasn't called yet at this point. They surface via the WS
-            // listener / catch-up REST on subsequent agent turns.
+            // Notifications fire from update_mappings, which the background task
+            // hasn't called yet. They surface via the WS listener / catch-up REST
+            // on subsequent turns.
             notification_ids: [],
             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
+              phase: importIds2.length > 0 ? "preprocess" : "queued",
+              records_processed: 0,
+              records_total: prep.validInputs.length
             },
             region: client.region,
-            ...reservation.reused ? {
-              reused: true,
-              seconds_since_original: reservation.seconds_since_original
-            } : {},
             _meta: client.lastMeta ?? {
               region: client.region,
               endpoint: "POST /imports",
@@ -11446,7 +11776,9 @@ var init_launch_bulk_enrichment = __esm({
         title: "Launch bulk enrichment",
         readOnlyHint: false,
         destructiveHint: true,
-        idempotentHint: true,
+        // No double-launch guard: this POSTs straight through, so an identical
+        // repeat is a second paid launch, not a no-op (product#4039).
+        idempotentHint: false,
         openWorldHint: true
       },
       description: leadbay_launch_bulk_enrichment,
@@ -15385,7 +15717,7 @@ var init_getting_started = __esm({
             leadIds: "[<the ONE lead you drafted for at step 3>] \u2014 an ARRAY, always",
             lensId: "<the pinned lens id from step 2>"
           },
-          spend: "TWO BEATS \u2014 free preview FIRST, the real reveal only after the user confirms. Beat 1: call leadbay_enrich_titles with the drafted lead's id + lensId and NO titles / NO confirm / NO email / NO phone. That returns mode:'discover' \u2014 the FREE list of job titles at that company. Say plainly that nothing has been spent yet. Beat 2: name the title the draft is addressed to, tell them BEFORE they decide what it costs (one credit per contact revealed \u2014 here that is ONE contact, one credit), and ask them to confirm. Only then call leadbay_enrich_titles AGAIN with leadIds: [<that lead id>] \u2014 ALWAYS the array, even for a single lead: `leadId` singular is not a key this tool reads, so it is dropped and the paid call falls back to the default wishlist selection, charging for the whole batch \u2014 plus the chosen title, confirm:true and email:true. Poll leadbay_bulk_enrich_status with the returned bulk_id until all_done (or the count plateaus), and report the contact that actually resolved. NEVER launch the reveal without an explicit confirm: silence is not consent, and neither is 'they clicked the gate'. If they decline, keep the draft and the title and move on \u2014 that is a normal outcome, not a failure.",
+          spend: "TWO BEATS \u2014 free preview FIRST, the real reveal only after the user confirms. Beat 1: call leadbay_enrich_titles with the drafted lead's id + lensId and NO titles / NO confirm / NO email / NO phone. That returns mode:'discover' \u2014 the FREE list of job titles at that company. Say plainly that nothing has been spent yet. Beat 2: name the title the draft is addressed to, tell them BEFORE they decide what it costs (one credit per contact revealed \u2014 here that is ONE contact, one credit), and ask them to confirm. Only then call leadbay_enrich_titles AGAIN with leadIds: [<that lead id>] \u2014 ALWAYS the array, even for a single lead: `leadId` singular is not a key this tool reads, so it is dropped and the paid call falls back to the default wishlist selection, charging for the whole batch \u2014 plus the chosen title, confirm:true and email:true. Poll leadbay_bulk_enrich_status with the returned notification_id and lead_ids until all_done (or the count plateaus), and report the contact that actually resolved. NEVER launch the reveal without an explicit confirm: silence is not consent, and neither is 'they clicked the gate'. If they decline, keep the draft and the title and move on \u2014 that is a normal outcome, not a failure.",
           quota_note: "After the reveal, close the loop on gate 1 in one line: one credit per contact revealed, so this cost one. Then say the thing that makes it land \u2014 the draft from gate 3 now has a real person and a real address to go to. Re-check leadbay_account_status if you want to show the moved windows. This is where gate 1's numbers stop being abstract: they just watched them move, and got something for it. Keep it to a line; no pricing pitch."
         }
       ],
@@ -16444,6 +16776,7 @@ var PAGE_SIZE, DEFAULT_COUNT2, MAX_COUNT, DEFAULT_PER_LEAD_BUDGET_MS, DEFAULT_TO
 var init_bulk_qualify_leads = __esm({
   "../core/dist/composite/bulk-qualify-leads.js"() {
     "use strict";
+    init_launch_guard();
     init_tool_descriptions_generated();
     PAGE_SIZE = 50;
     DEFAULT_COUNT2 = 10;
@@ -16488,7 +16821,7 @@ var init_bulk_qualify_leads = __esm({
           },
           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."
+            description: "When false, launch qualification and return `{status:'running', notification_id, lead_ids, lens_id}` immediately. Poll leadbay_qualify_status with them. Default is true for 0.6.x backwards compatibility."
           }
         },
         additionalProperties: false
@@ -16505,13 +16838,15 @@ var init_bulk_qualify_leads = __esm({
             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." },
+          notification_id: {
+            type: ["string", "null"],
+            description: "The backend's job id. Carry it to 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).",
+            description: "Leads launched but whose qualification did not complete within budget. Re-poll via leadbay_qualify_status with notification_id (when present) or lead_ids + lens_id.",
             items: { type: "object" }
           },
           failed: {
@@ -16545,8 +16880,7 @@ var init_bulk_qualify_leads = __esm({
           {
             required: [
               "status",
-              "handle_id",
-              "qualify_id",
+              "notification_id",
               "lead_ids",
               "launched_count",
               "failed",
@@ -16606,45 +16940,45 @@ var init_bulk_qualify_leads = __esm({
           };
         }
         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 fingerprint = launchFingerprint(["qualify", candidates, lensId]);
+          const claim = beginLaunch(fingerprint);
+          if (claim.state === "in_flight") {
+            throw client.makeError("QUALIFY_LAUNCH_IN_FLIGHT", `An identical qualification was started ${claim.seconds_since}s ago and has not returned its job id yet`, "Nothing was launched twice. Call leadbay_bulk_qualify_leads again with the same arguments in a few seconds to receive the notification_id.", "");
           }
-          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
-          });
-          let launchedCount = 0;
-          let notificationId = null;
-          let quotaExceeded2 = false;
-          let failed2 = [];
-          if (!reservation.reused) {
-            const launch = await launchBulkQualify(client, candidates, ctx);
-            quotaExceeded2 = launch.quotaExceeded;
-            notificationId = launch.resp?.notification_id ?? null;
-            const queuedIds = launch.resp?.queued_ids ?? [];
-            const skippedIds = launch.resp?.skipped_ids ?? [];
-            launchedCount = queuedIds.length;
-            const seen = /* @__PURE__ */ new Set([...queuedIds, ...skippedIds]);
-            failed2 = candidates.filter((id) => !seen.has(id)).map((id) => ({ lead_id: id, error: "not_queued" }));
-            if (queuedIds.length > 0 || quotaExceeded2 || skippedIds.length > 0 || failed2.length === candidates.length) {
-              await ctx.bulkTracker.markLaunched(reservation.record.bulk_id, notificationId);
-            }
-          } else {
-            notificationId = reservation.record.notification_id ?? null;
-            launchedCount = reservation.record.lead_ids.length;
+          const already = claim.state === "settled" ? claim.record : void 0;
+          if (already) {
+            return {
+              status: "running",
+              lead_ids: candidates,
+              launched_count: candidates.length,
+              failed: [],
+              quota_exceeded: false,
+              lens_id: lensId,
+              notification_id: already.notification_id,
+              reused: true,
+              seconds_since_original_launch: already.seconds_since,
+              _meta: { region: client.region }
+            };
+          }
+          let launch;
+          try {
+            launch = await launchBulkQualify(client, candidates, ctx);
+          } catch (err) {
+            abandonLaunch(fingerprint);
+            throw err;
           }
+          const notificationId = launch.resp?.notification_id ?? null;
+          const queuedIds = launch.resp?.queued_ids ?? [];
+          const skippedIds = launch.resp?.skipped_ids ?? [];
+          const seen = /* @__PURE__ */ new Set([...queuedIds, ...skippedIds]);
+          const failed2 = candidates.filter((id) => !seen.has(id)).map((id) => ({ lead_id: id, error: "not_queued" }));
+          rememberLaunch(fingerprint, notificationId);
           const out = {
             status: "running",
-            handle_id: reservation.record.bulk_id,
-            qualify_id: reservation.record.bulk_id,
             lead_ids: candidates,
-            launched_count: launchedCount,
+            launched_count: queuedIds.length,
             failed: failed2,
-            quota_exceeded: quotaExceeded2,
+            quota_exceeded: launch.quotaExceeded,
             lens_id: lensId,
             notification_id: notificationId,
             _meta: { region: client.region }
@@ -17255,6 +17589,7 @@ var DEFAULT_PER_LEAD_BUDGET_MS2, DEFAULT_TOTAL_BUDGET_MS3, DEFAULT_PER_PHASE_BUD
 var init_import_and_qualify = __esm({
   "../core/dist/composite/import-and-qualify.js"() {
     "use strict";
+    init_launch_guard();
     init_tool_descriptions_generated();
     init_import_leads();
     init_qualify_helpers();
@@ -17341,7 +17676,7 @@ var init_import_and_qualify = __esm({
           },
           total_budget_ms: {
             type: "number",
-            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.`
+            description: `Total wall-clock budget across import + qualify in ms (default ${DEFAULT_TOTAL_BUDGET_MS3}). When exhausted, the response returns lead_ids + lens_id for resume via leadbay_qualify_status.`
           },
           per_phase_budget_ms: {
             type: "number",
@@ -17349,7 +17684,7 @@ var init_import_and_qualify = __esm({
           },
           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."
+            description: "When false, upload the rows and return `{kind:'result', status:'running', import_ids}` immediately. Poll leadbay_import_status({importIds, dry_run}); the qualify phase does NOT run on this path \u2014 call leadbay_bulk_qualify_leads on the imported leads yourself. Default is true."
           },
           lensId: {
             type: "number",
@@ -17372,7 +17707,7 @@ var init_import_and_qualify = __esm({
       },
       outputSchema: {
         type: "object",
-        description: "Two return shapes: kind:'preview' (when dry_run='preview') with mapping hints; kind:'result' (default) with imported + qualified leads + qualify_id handle.",
+        description: "Two return shapes: kind:'preview' (when dry_run='preview') with mapping hints; kind:'result' (default) with imported + qualified leads + lead_ids/lens_id to resume via leadbay_qualify_status.",
         properties: {
           kind: {
             type: "string",
@@ -17382,10 +17717,6 @@ var init_import_and_qualify = __esm({
             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."
-          },
           timed_out: {
             type: "boolean",
             description: "True when the underlying import ran out of poll budget. Still running server-side \u2014 poll leadbay_import_status(import_ids). Do NOT re-issue the import."
@@ -17430,10 +17761,12 @@ var init_import_and_qualify = __esm({
             type: "object",
             description: "Adaptive budgets the composite selected (when caller didn't override): {per_lead_budget_ms, total_budget_ms, per_phase_budget_ms, wall_clock_estimate_ms, strategy}."
           },
-          qualify_id: {
-            type: ["string", "null"],
-            description: "UUIDv4 handle for polling via leadbay_qualify_status. Null when no leads were qualified."
+          lead_ids: {
+            type: "array",
+            description: "Leads the qualify phase covers. Pass to leadbay_qualify_status for per-lead detail.",
+            items: { type: "string" }
           },
+          lens_id: { type: "number", description: "Lens the qualification ran against." },
           import_ids: {
             type: "array",
             description: "Backend file-import handles (one per chunk).",
@@ -17456,7 +17789,7 @@ var init_import_and_qualify = __esm({
           },
           still_running: {
             type: "array",
-            description: "Leads still being qualified at deadline; agent calls leadbay_qualify_status with qualify_id.",
+            description: "Leads still being qualified at deadline; agent calls leadbay_qualify_status with lead_ids + lens_id.",
             items: { type: "object" }
           },
           failed: {
@@ -17477,10 +17810,13 @@ var init_import_and_qualify = __esm({
           },
           reused: {
             type: "boolean",
-            description: "True when an identical qualify_id was launched within the idempotency window."
+            description: "True when an identical launch was reused within the idempotency window."
           },
           seconds_since_original: { type: "number" },
-          cancelled: { type: "boolean", description: "True when ctx.signal aborted mid-flight." },
+          cancelled: {
+            type: "boolean",
+            description: "True when the HOST cancelled the call (a user Cancel, or the host's own request timeout); a budget timeout reports `budget_exhausted` instead. The import and the qualifications already launched keep running on Leadbay, except a chunk cancelled before its mappings were committed, which can read `running` without ever progressing \u2014 if the counts stop moving, say so rather than polling on. Poll leadbay_import_status with the `import_ids` values passed as `importIds`, and leadbay_qualify_status with lead_ids + lens_id. `still_running` can also hold leads whose qualification was never launched; those need a fresh qualification, which qualify_status cannot start."
+          },
           budget_exhausted: { type: "boolean", description: "True when total_budget_ms hit before all leads finished." },
           quota_blocked: { type: "boolean", description: "True when quota was exhausted before launching all leads." },
           region: { type: "string" },
@@ -17502,9 +17838,6 @@ var init_import_and_qualify = __esm({
         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.", "");
-        }
         if (params.wait_for_completion === false) {
           const queued = await importLeads.execute(client, {
             domains: params.domains,
@@ -17519,7 +17852,8 @@ var init_import_and_qualify = __esm({
             return {
               kind: "result",
               ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
-              qualify_id: null,
+              lead_ids: [],
+              lens_id: 0,
               import_ids: queued.importIds,
               notification_ids: queued.notification_ids ?? [],
               imported: queued.leads.map((l) => ({
@@ -17542,9 +17876,9 @@ var init_import_and_qualify = __esm({
           return {
             kind: "result",
             status: "running",
-            ...queued.handle_id ? { handle_id: queued.handle_id } : {},
             ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
-            qualify_id: null,
+            lead_ids: [],
+            lens_id: 0,
             import_ids: queued.importIds,
             notification_ids: queued.notification_ids ?? [],
             imported: [],
@@ -17577,7 +17911,6 @@ var init_import_and_qualify = __esm({
           return {
             kind: "result",
             status: "running",
-            ...importResultRaw.handle_id ? { handle_id: importResultRaw.handle_id } : {},
             // Everything the rendering contract keys off has to survive the
             // wrapper. Without `timed_out` the agent can't tell this from a
             // deliberate async launch; without `rows_pending_upload` a >100-row
@@ -17589,7 +17922,8 @@ var init_import_and_qualify = __esm({
             ...importResultRaw.dry_run ? { dry_run: true } : {},
             ...importResultRaw.row_ids ? { row_ids: importResultRaw.row_ids } : {},
             ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
-            qualify_id: null,
+            lead_ids: [],
+            lens_id: 0,
             import_ids: importResultRaw.importIds,
             notification_ids: importResultRaw.notification_ids ?? [],
             imported: [],
@@ -17610,7 +17944,8 @@ var init_import_and_qualify = __esm({
             kind: "result",
             ...params.dry_run === true ? { dry_run: true } : {},
             ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
-            qualify_id: null,
+            lead_ids: [],
+            lens_id: 0,
             import_ids: importResult.importIds,
             notification_ids: importResult.notification_ids ?? [],
             imported: [],
@@ -17648,7 +17983,8 @@ var init_import_and_qualify = __esm({
             kind: "result",
             ...params.dry_run === true ? { dry_run: true } : {},
             ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
-            qualify_id: null,
+            lead_ids: [],
+            lens_id: 0,
             import_ids: importResult.importIds,
             notification_ids: importResult.notification_ids ?? [],
             imported,
@@ -17694,29 +18030,17 @@ var init_import_and_qualify = __esm({
           // 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 {
-            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}`);
-          }
-        }
-        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`);
+        const qualifyFingerprint = launchFingerprint([
+          "import_qualify",
+          leadIds,
+          importResult.importIds,
+          lensId,
+          mappingFp
+        ]);
+        const qualifyClaim = beginLaunch(qualifyFingerprint);
+        const alreadyQualified = qualifyClaim.state === "settled" ? qualifyClaim.record : void 0;
+        if (alreadyQualified) {
+          ctx?.logger?.info?.(`import_and_qualify: identical qualify ran ${alreadyQualified.seconds_since}s ago; re-running the fan-out to report current per-lead state (already-qualified leads are skipped inside it)`);
         }
         let questionOrder = void 0;
         try {
@@ -17730,22 +18054,24 @@ var init_import_and_qualify = __esm({
           total: 3,
           message: `Qualifying ${leadIds.length} lead${leadIds.length === 1 ? "" : "s"} (phase 3/3)`
         });
-        const fanOut = await fanOutWebFetchAndPoll(client, leadIds, {
-          perLeadBudgetMs: perLeadBudget,
-          totalDeadlineMs: totalDeadline,
-          signal,
-          ctx,
-          skipAlreadyQualifiedLensId: lensId,
-          skipAlreadyQualifiedLaunch: skipAlreadyQualified,
-          ...questionOrder ? { questionOrder } : {}
-        });
-        if (fanOut.cancelled) {
-          try {
-            await ctx.bulkTracker.markCancelled(reservation.record.bulk_id);
-          } catch (err) {
-            ctx?.logger?.warn?.(`import_and_qualify: tracker.markCancelled failed: ${err?.message ?? err}`);
-          }
+        let fanOut;
+        try {
+          fanOut = await fanOutWebFetchAndPoll(client, leadIds, {
+            perLeadBudgetMs: perLeadBudget,
+            totalDeadlineMs: totalDeadline,
+            signal,
+            ctx,
+            skipAlreadyQualifiedLensId: lensId,
+            skipAlreadyQualifiedLaunch: skipAlreadyQualified,
+            ...questionOrder ? { questionOrder } : {}
+          });
+        } catch (err) {
+          if (!alreadyQualified)
+            abandonLaunch(qualifyFingerprint);
+          throw err;
         }
+        if (!alreadyQualified)
+          rememberLaunch(qualifyFingerprint, null);
         const qualified = fanOut.results.filter((r) => !r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
         const notInLensSet = new Set(fanOut.not_in_lens);
         const stillRunningIds = new Set([
@@ -17759,7 +18085,8 @@ var init_import_and_qualify = __esm({
         return {
           kind: "result",
           ...chosenBudgets ? { chosen_budgets: chosenBudgets } : {},
-          qualify_id: reservation.record.bulk_id,
+          lead_ids: leadIds,
+          lens_id: lensId,
           import_ids: importResult.importIds,
           notification_ids: importResult.notification_ids ?? [],
           imported,
@@ -17770,9 +18097,9 @@ var init_import_and_qualify = __esm({
           quota_exceeded: fanOut.quota_exceeded,
           skipped_already_qualified,
           not_in_lens: fanOut.not_in_lens,
-          ...reservation.reused ? {
+          ...alreadyQualified ? {
             reused: true,
-            seconds_since_original: reservation.seconds_since_original
+            seconds_since_original: alreadyQualified.seconds_since
           } : {},
           ...fanOut.cancelled ? { cancelled: true } : {},
           ...budgetExhausted ? { budget_exhausted: true } : {},
@@ -17790,708 +18117,72 @@ var init_import_and_qualify = __esm({
   }
 });
 
-// ../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 as createHash3, randomUUID as randomUUID2 } from "crypto";
-function isValidBulkId(v) {
-  return typeof v === "string" && UUIDV4_RE.test(v);
-}
-function computeIdempotencyKey(args) {
-  const parts = [
-    [...args.lead_ids].sort().join(","),
-    [...args.titles].sort().join(","),
-    args.email ? "e1" : "e0",
-    args.phone ? "p1" : "p0",
-    `l${args.lens_id}`
-  ];
-  return createHash3("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 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) {
+// ../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 {
-    lead_ids: [...new Set(args.lead_ids)].sort(),
-    titles: [...new Set(args.titles)].sort()
+    phase,
+    records_processed: recordsProcessed,
+    records_total: recordsTotal
   };
 }
-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;
-  }
+function isInProgress(err) {
+  return /in_progress/i.test(String(err?.message ?? ""));
 }
-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);
+async function fetchReconciledRecords(client, importIds, declaredTotal, ctx) {
+  const canonicalLeadIds = /* @__PURE__ */ new Set();
+  for (const importId of importIds) {
+    try {
+      const res = await client.request("GET", `/imports/${importId}/leads`);
+      for (const id of res?.lead_ids ?? [])
+        canonicalLeadIds.add(id);
+    } catch (err) {
+      if (isInProgress(err))
+        throw new ImportNotReady();
+      if (err?.code !== "NOT_FOUND" && err?._meta?.http_status !== 404)
+        throw err;
+      ctx?.logger?.warn?.(`import-status: /imports/${importId}/leads not available on this backend (404) \u2014 using records only`);
     }
-    opts.logger?.warn?.(`bulk.fallback_memory path=${path} reason=${err?.message ?? err}`);
-    return new LocalBulkStore({ backend: "memory", logger: opts.logger });
   }
-}
-var DEFAULT_IDEMPOTENCY_WINDOW_MS, TTL_MS, UUIDV4_RE, AsyncMutex, LocalBulkStore, InMemoryBulkStore;
-var init_bulk_store = __esm({
-  "../core/dist/jobs/bulk-store.js"() {
-    "use strict";
-    DEFAULT_IDEMPOTENCY_WINDOW_MS = 5 * 60 * 1e3;
-    TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-    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;
-    AsyncMutex = class {
-      locked = false;
-      queue = [];
-      async lock() {
-        if (!this.locked) {
-          this.locked = true;
-          return;
-        }
-        return new Promise((resolve) => {
-          this.queue.push(() => {
-            this.locked = true;
-            resolve();
-          });
-        });
-      }
-      unlock() {
-        this.locked = false;
-        const next = this.queue.shift();
-        if (next)
-          next();
-      }
-      async run(fn) {
-        await this.lock();
-        try {
-          return await fn();
-        } finally {
-          this.unlock();
-        }
-      }
-    };
-    LocalBulkStore = class {
-      backend;
-      path;
-      logger;
-      allowUnsafePath;
-      now;
-      mutex = new AsyncMutex();
-      memory = [];
-      // Cached file resolution — computed lazily on first access.
-      initialized = false;
-      constructor(opts) {
-        this.backend = opts.backend;
-        this.logger = opts.logger;
-        this.allowUnsafePath = !!opts.allowUnsafePath;
-        this.now = opts.now ?? Date.now;
-        if (this.backend === "file") {
-          if (!opts.path) {
-            throw new Error("LocalBulkStore: path is required when backend=file");
-          }
-          this.path = resolvePath(opts.path);
-          this.validatePath(this.path);
-        }
-      }
-      get durability() {
-        return this.backend;
-      }
-      // Exposed for tests and ops tooling.
-      get resolvedPath() {
-        return this.path;
-      }
-      validatePath(p) {
-        if (this.allowUnsafePath)
-          return;
-        const home = resolvePath(homedir());
-        if (p !== home && !p.startsWith(home + "/") && !p.startsWith(home + "\\")) {
-          throw new Error(`LocalBulkStore: path ${p} is outside $HOME (${home}). Set LEADBAY_BULK_STORE_PATH_UNSAFE=1 to override.`);
-        }
-      }
-      async ensureInitialized() {
-        if (this.initialized || this.backend !== "file") {
-          this.initialized = true;
-          return;
-        }
-        const dir = dirname(this.path);
-        await mkdirAsync(dir, { recursive: true, mode: 448 });
-        try {
-          const st = await lstat(this.path);
-          if (st.isSymbolicLink()) {
-            throw new Error(`LocalBulkStore: refusing to use ${this.path} \u2014 path is a symlink. Set LEADBAY_BULK_STORE_PATH_UNSAFE=1 to override.`);
-          }
-        } catch (err) {
-          if (err?.code !== "ENOENT")
-            throw err;
-        }
-        this.initialized = true;
-      }
-      // ─── Storage layer (file or memory) ──────────────────────────────────────
-      async readAll() {
-        if (this.backend === "memory")
-          return [...this.memory];
-        await this.ensureInitialized();
-        let raw;
-        try {
-          raw = await readFile(this.path, "utf8");
-        } catch (err) {
-          if (err?.code === "ENOENT")
-            return [];
-          throw err;
-        }
-        let parsed;
-        try {
-          parsed = JSON.parse(raw);
-        } catch (err) {
-          this.logger?.warn?.(`bulk.record_dropped file_parse_failed ${err?.message ?? err}`);
-          return [];
-        }
-        if (!Array.isArray(parsed)) {
-          this.logger?.warn?.("bulk.record_dropped file_not_array");
-          return [];
-        }
-        const out = [];
-        for (const entry of parsed) {
-          try {
-            out.push(this.validateRecord(entry));
-          } catch (err) {
-            this.logger?.warn?.(`bulk.record_dropped invalid_record ${err?.message ?? err}`);
-          }
-        }
-        return out;
-      }
-      validateRecord(raw) {
-        if (!raw || typeof raw !== "object")
-          throw new Error("not an object");
-        const r = raw;
-        if (!isValidBulkId(r.bulk_id))
-          throw new Error("invalid bulk_id");
-        if (typeof r.launched_at !== "string")
-          throw new Error("missing launched_at");
-        if (!Array.isArray(r.lead_ids) || !r.lead_ids.every((x) => typeof x === "string"))
-          throw new Error("invalid lead_ids");
-        if (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");
-        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 === "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");
-          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.notification_id != null && typeof r.notification_id !== "string")
-            throw new Error("invalid notification_id");
-          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,
-            // Preserve the persisted notification_id — dropping it on reload forced
-            // bulk_enrich_status onto the legacy per-lead fallback every time
-            // (the fast path keys off record.notification_id), even in production
-            // where the default store is file-backed.
-            ...r.notification_id != null ? { notification_id: r.notification_id } : {},
-            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 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, notification_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",
-            ...notification_id ? { notification_id } : {}
-          };
-          await this.writeAll(all);
-          this.logger?.info?.(`bulk.launched bulk_id=${bulk_id}${notification_id ? ` notification_id=${notification_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 markCancelled(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: "cancelled" };
-          await this.writeAll(all);
-          this.logger?.info?.(`bulk.cancelled 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));
-        });
-      }
-    };
-    InMemoryBulkStore = class extends LocalBulkStore {
-      constructor(opts = {}) {
-        super({ backend: "memory", logger: opts.logger, now: opts.now });
-      }
-    };
-  }
-});
-
-// ../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
-  };
-}
-function isInProgress(err) {
-  return /in_progress/i.test(String(err?.message ?? ""));
-}
-async function fetchReconciledRecords(client, importIds, declaredTotal, ctx) {
-  const canonicalLeadIds = /* @__PURE__ */ new Set();
-  for (const importId of importIds) {
-    try {
-      const res = await client.request("GET", `/imports/${importId}/leads`);
-      for (const id of res?.lead_ids ?? [])
-        canonicalLeadIds.add(id);
-    } catch (err) {
-      if (isInProgress(err))
-        throw new ImportNotReady();
-      if (err?.code !== "NOT_FOUND" && err?._meta?.http_status !== 404)
-        throw err;
-      ctx?.logger?.warn?.(`import-status: /imports/${importId}/leads not available on this backend (404) \u2014 using records only`);
-    }
-  }
-  const all = [];
-  for (const importId of importIds) {
-    for (let page = 0; page < RECORDS_MAX_PAGES; page++) {
-      const qs = `count=${RECORDS_PAGE_SIZE}&page=${page}&automatic_match=true&manual_match=true&no_match=true&matching=true&importing=true&imported=true`;
-      let res;
-      try {
-        res = await client.request("GET", `/imports/${importId}/records?${qs}`);
-      } catch (err) {
-        if (isInProgress(err))
-          throw new ImportNotReady();
-        throw err;
+  const all = [];
+  for (const importId of importIds) {
+    for (let page = 0; page < RECORDS_MAX_PAGES; page++) {
+      const qs = `count=${RECORDS_PAGE_SIZE}&page=${page}&automatic_match=true&manual_match=true&no_match=true&matching=true&importing=true&imported=true`;
+      let res;
+      try {
+        res = await client.request("GET", `/imports/${importId}/records?${qs}`);
+      } catch (err) {
+        if (isInProgress(err))
+          throw new ImportNotReady();
+        throw err;
       }
       all.push(...res.items);
       const totalPages = res.pagination.pages ?? 0;
@@ -18529,7 +18220,6 @@ var RECORDS_PAGE_SIZE, RECORDS_MAX_PAGES, ImportNotReady, importStatus;
 var init_import_status = __esm({
   "../core/dist/composite/import-status.js"() {
     "use strict";
-    init_bulk_store();
     init_import_records();
     init_import_commit_log();
     init_tool_descriptions_generated();
@@ -18550,10 +18240,6 @@ var init_import_status = __esm({
       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: "Backend file-import ids to inspect directly \u2014 from a completed import's `importIds`, or from a `{status:'running', timed_out:true}` result.",
@@ -18570,12 +18256,11 @@ var init_import_status = __esm({
         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: {leads, not_imported, importIds, still_settling?}. Present when a handle_id resolves a completed run in this MCP instance, OR when the importIds[] path finds every import complete and reconciles the wizard's records."
+            description: "Final import result: {leads, not_imported, importIds, still_settling?}. Present when the importIds[] path finds every import complete and reconciles the wizard's records."
           },
           error: { type: "string" },
           dry_run: {
@@ -18588,99 +18273,20 @@ var init_import_status = __esm({
         required: ["status", "importIds", "progress", "region", "_meta"]
       },
       execute: async (client, params, ctx) => {
-        let handleId = params.handle_id;
         let importIds = params.importIds ?? [];
-        let handleDryRun = params.dry_run;
-        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 ?? handleDryRun;
-          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
-              }
-            };
-          }
-        }
         importIds = [...new Set(importIds)];
         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.", "");
+          throw client.makeError("IMPORT_STATUS_INPUT_REQUIRED", "Pass importIds[]", "Call leadbay_import_leads with wait_for_completion=false first, then pass back the importIds it returned.", "");
         }
         const imports = await Promise.all(importIds.map((id) => client.request("GET", `/imports/${id}`)));
-        const progress = summarizeImports(imports, handleDryRun);
+        const progress = summarizeImports(imports, params.dry_run);
         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)
+          if (params.dry_run === true)
             return Boolean(i.pre_processing?.finished);
-          if (handleDryRun === false)
+          if (params.dry_run === false)
             return Boolean(i.processing?.finished);
           return Boolean(i.processing?.finished || i.pre_processing?.finished && !i.processing);
         });
@@ -18688,7 +18294,7 @@ var init_import_status = __esm({
         const commitError = commitFailureFor(importIds);
         let notReady = false;
         const declaredTotal = imports.reduce((n, i) => n + Number(i.total_records ?? 0), 0);
-        if (!failed && complete && handleDryRun !== true && importIds.length > 0) {
+        if (!failed && complete && params.dry_run !== true && importIds.length > 0) {
           try {
             reconciled = await fetchReconciledRecords(client, importIds, declaredTotal, ctx);
           } catch (err) {
@@ -18703,9 +18309,8 @@ var init_import_status = __esm({
         const settled = complete && !notReady;
         return {
           status: failed || commitError ? "failed" : settled ? "complete" : "running",
-          ...handleId ? { handle_id: handleId } : {},
           importIds,
-          ...handleDryRun === true ? { dry_run: true } : {},
+          ...params.dry_run === true ? { dry_run: true } : {},
           progress: notReady ? { ...progress, phase: "committing" } : progress,
           ...reconciled ? {
             result: {
@@ -18731,20 +18336,42 @@ var init_import_status = __esm({
   }
 });
 
-// ../core/dist/composite/qualify-status.js
-async function readNotification(client, notificationId) {
-  try {
-    const page = await client.listNotifications({ archived: false, count: 50 });
-    return page.items.find((n) => n.id === notificationId) ?? null;
-  } catch {
-    return null;
+// ../core/dist/notifications/read-by-id.js
+async function readNotificationById(client, notificationId) {
+  for (const archived of [false, true]) {
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+      let res;
+      try {
+        res = await client.listNotifications({ archived, page, count: PAGE_SIZE2 });
+      } catch {
+        return null;
+      }
+      const hit = res.items.find((n) => n.id === notificationId);
+      if (hit)
+        return hit;
+      const pages = res.pagination?.pages ?? 1;
+      if (page + 1 >= pages)
+        break;
+    }
   }
+  return null;
 }
+var PAGE_SIZE2, MAX_PAGES;
+var init_read_by_id = __esm({
+  "../core/dist/notifications/read-by-id.js"() {
+    "use strict";
+    PAGE_SIZE2 = 50;
+    MAX_PAGES = 4;
+  }
+});
+
+// ../core/dist/composite/qualify-status.js
 var qualifyStatus;
 var init_qualify_status = __esm({
   "../core/dist/composite/qualify-status.js"() {
     "use strict";
-    init_bulk_store();
+    init_read_by_id();
+    init_revise_hint();
     init_qualify_helpers();
     init_tool_descriptions_generated();
     qualifyStatus = {
@@ -18760,18 +18387,30 @@ var init_qualify_status = __esm({
       inputSchema: {
         type: "object",
         properties: {
-          qualify_id: {
+          notification_id: {
             type: "string",
-            description: "UUIDv4 returned by leadbay_import_and_qualify when at least one lead was still running."
+            description: "The `notification_id` returned by leadbay_import_and_qualify / leadbay_bulk_qualify_leads. Answers progress in ONE call."
+          },
+          lead_ids: {
+            type: "array",
+            description: "The `lead_ids` the launch returned. Supply them for per-lead detail (which settled, which are still running). Progress alone needs only notification_id.",
+            items: { type: "string" }
+          },
+          lens_id: {
+            type: "number",
+            description: "The `lens_id` the launch returned. Used to flag leads no longer in the lens."
           }
         },
-        required: ["qualify_id"],
+        anyOf: [{ required: ["notification_id"] }, { required: ["lead_ids"] }],
         additionalProperties: false
       },
       outputSchema: {
         type: "object",
         properties: {
-          qualify_id: { type: "string", description: "Echoed UUIDv4 handle." },
+          notification_id: {
+            type: ["string", "null"],
+            description: "The backend job id this status is for; pass it back to poll again."
+          },
           launched_at: { type: "string", description: "ISO timestamp of original launch." },
           status: { type: "string", description: "'launched' on success (other states surface as error envelopes)." },
           import_ids: {
@@ -18782,7 +18421,7 @@ var init_qualify_status = __esm({
           lens_id: { type: "number", description: "Lens id the qualification ran against." },
           lead_ids: {
             type: "array",
-            description: "Lead UUIDs covered by this qualify_id (echoed from launch).",
+            description: "Lead UUIDs covered by this status (echoed from launch).",
             items: { type: "string" }
           },
           qualified: {
@@ -18817,7 +18456,7 @@ var init_qualify_status = __esm({
           _meta: { type: "object" }
         },
         required: [
-          "qualify_id",
+          "notification_id",
           "status",
           "import_ids",
           "lens_id",
@@ -18831,29 +18470,55 @@ var init_qualify_status = __esm({
         ]
       },
       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.", "");
-        }
-        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 notifId = params.notification_id ?? null;
+        const leadIds = params.lead_ids ?? [];
+        if (!notifId && leadIds.length === 0) {
+          throw client.makeError("QUALIFY_STATUS_INPUT_REQUIRED", "Pass notification_id (for progress) and/or lead_ids (for per-lead detail)", "Both are in the launch response from leadbay_bulk_qualify_leads / leadbay_import_and_qualify. Re-read that result and pass them back.", "");
         }
-        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") {
-            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, "");
+        let bulkProgress = null;
+        let inProgressFlag = null;
+        let launchedAt = null;
+        if (notifId) {
+          const n = await readNotificationById(client, notifId);
+          if (!n && leadIds.length === 0) {
+            throw client.makeError("QUALIFY_JOB_NOT_FOUND", "No job for that notification_id", "The lookup scans this user's recent notifications (archived included); a job behind many newer ones will not be found. Re-call with the `lead_ids` + `lens_id` the launch returned \u2014 that answers per lead without the notification.", "");
+          }
+          if (n && inferKind(n) !== "bulk_qualify") {
+            const kind = inferKind(n);
+            throw client.makeError("QUALIFY_JOB_WRONG_KIND", `That notification_id is a ${kind === "bulk_enrich" ? "contact enrichment" : kind === "import" ? "file import" : "non-bulk"} notification, not a lead qualification`, kind === "bulk_enrich" ? "Poll it with leadbay_bulk_enrich_status({notification_id, lead_ids, titles, email, phone}) instead \u2014 carry the titles and channel the enrichment was launched with, or a contact enriched earlier counts as done and all_done flips true before anything landed." : kind === "import" ? "Poll it with leadbay_import_status({importIds}) instead." : "Pass the notification_id returned by leadbay_bulk_qualify_leads.", "");
+          }
+          if (n) {
+            bulkProgress = n.bulk_progress;
+            inProgressFlag = n.in_progress;
+            launchedAt = n.created_at;
           }
-          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.", "");
-        }
-        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.", "");
-        }
-        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.", "");
         }
-        if (record.status === "cancelled") {
-          throw client.makeError("BULK_CANCELLED", "The qualify run was cancelled (ctx.signal aborted by the client mid-flight); no further qualifications are in flight", "Call leadbay_import_and_qualify again with the same input to relaunch \u2014 the cancelled record won't block a fresh launch.", "");
+        if (leadIds.length === 0) {
+          const out2 = {
+            notification_id: notifId,
+            launched_at: launchedAt ?? "",
+            status: "launched",
+            import_ids: [],
+            lens_id: params.lens_id ?? 0,
+            lead_ids: [],
+            qualified: [],
+            still_running: [],
+            failed: [],
+            not_in_lens: [],
+            bulk_progress: bulkProgress,
+            in_progress: inProgressFlag,
+            region: client.region,
+            _meta: client.lastMeta ?? {
+              region: client.region,
+              endpoint: "GET /notifications",
+              latency_ms: null,
+              retry_after: null
+            }
+          };
+          if (bulkProgress && bulkProgress.quota_hit_count > 0) {
+            out2.quota_hit_hint = "Some leads hit the AI-credits quota during qualification. Top up via leadbay_create_topup_link to clear the throttle immediately, or wait until the daily/weekly window resets.";
+          }
+          return out2;
         }
         ctx?.progress?.({
           progress: 1,
@@ -18869,20 +18534,20 @@ var init_qualify_status = __esm({
         ctx?.progress?.({
           progress: 2,
           total: 3,
-          message: `Checking lens membership for ${record.lead_ids.length} lead${record.lead_ids.length === 1 ? "" : "s"}\u2026`
+          message: `Checking lens membership for ${leadIds.length} lead${leadIds.length === 1 ? "" : "s"}\u2026`
         });
         let notInLensSet = /* @__PURE__ */ new Set();
         try {
-          const pre = await prequalifiedLeads(client, record.lead_ids, record.lens_id, ctx);
+          const pre = await prequalifiedLeads(client, leadIds, params.lens_id ?? 0, ctx);
           notInLensSet = pre.not_in_lens;
         } catch {
         }
         ctx?.progress?.({
           progress: 3,
           total: 3,
-          message: `Refreshing qualification state for ${record.lead_ids.length} lead${record.lead_ids.length === 1 ? "" : "s"}\u2026`
+          message: `Refreshing qualification state for ${leadIds.length} lead${leadIds.length === 1 ? "" : "s"}\u2026`
         });
-        const fresh = await refreshLeadStates(client, record.lead_ids, questionOrder);
+        const fresh = await refreshLeadStates(client, leadIds, questionOrder);
         const failed = [];
         const qualified = [];
         const still_running = [];
@@ -18901,28 +18566,17 @@ var init_qualify_status = __esm({
           const { _stillRunning, _failedCode, ...rest } = r;
           qualified.push(rest);
         }
-        let bulkProgress = null;
-        let inProgressFlag = null;
-        const notifId = record.notification_id ?? null;
-        if (notifId) {
-          const n = await readNotification(client, notifId);
-          if (n) {
-            bulkProgress = n.bulk_progress;
-            inProgressFlag = n.in_progress;
-          }
-        }
         const out = {
-          qualify_id: record.bulk_id,
-          launched_at: record.launched_at,
-          status: record.status === "complete" ? "launched" : record.status,
-          import_ids: record.import_ids,
-          lens_id: record.lens_id,
-          lead_ids: record.lead_ids,
+          notification_id: notifId,
+          launched_at: launchedAt ?? "",
+          status: "launched",
+          import_ids: [],
+          lens_id: params.lens_id ?? 0,
+          lead_ids: leadIds,
           qualified,
           still_running,
           failed,
           not_in_lens: [...notInLensSet],
-          notification_id: notifId,
           bulk_progress: bulkProgress,
           in_progress: inProgressFlag,
           region: client.region,
@@ -18933,10 +18587,6 @@ var init_qualify_status = __esm({
             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;
         if (bulkProgress && bulkProgress.quota_hit_count > 0) {
           out.quota_hit_hint = "Some leads hit the AI-credits quota during qualification. Top up via leadbay_create_topup_link to clear the throttle immediately, or wait until the daily/weekly window resets.";
         }
@@ -18949,171 +18599,81 @@ var init_qualify_status = __esm({
 // ../core/dist/composite/enrich-titles.js
 async function launchOnSelection(client, args, ctx) {
   const { leadIds, titles, email, phone, lensId, selectionSource, preview } = args;
-  {
-    {
-      const tracker = ctx?.bulkTracker;
-      let bulkRecord;
-      let bulkReused = false;
-      let bulkSecondsSinceOriginal;
-      if (tracker) {
-        const res = await tracker.findOrCreatePending({
-          lead_ids: leadIds,
-          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;
-        const AGED_PENDING_S = 60;
-        const agedPending = bulkReused && res.record.status === "pending" && (bulkSecondsSinceOriginal ?? 0) >= AGED_PENDING_S;
-        if (agedPending) {
-          const staleBulkId = res.record.bulk_id;
-          try {
-            await tracker.markFailed(staleBulkId);
-          } catch (e) {
-            ctx?.logger?.warn?.(`enrich_titles: markFailed on aged pending failed: ${e?.message ?? e}`);
-          }
-          bulkReused = false;
-          const fresh = await tracker.findOrCreatePending({
-            lead_ids: leadIds,
-            titles,
-            email,
-            phone,
-            lens_id: lensId,
-            selection_source: selectionSource
-          });
-          if (fresh.reused && fresh.record.bulk_id !== staleBulkId) {
-            return {
-              mode: "already_launched",
-              re_used: true,
-              bulk_id: fresh.record.bulk_id,
-              launched_at: fresh.record.launched_at,
-              durability: fresh.record.durability,
-              notification_id: fresh.record.notification_id ?? null,
-              seconds_since_original_launch: fresh.seconds_since_original ?? 0,
-              lead_ids: leadIds,
-              titles,
-              email,
-              phone,
-              preview,
-              message: "No new enrichment was ordered; quota not spent. A concurrent identical launch is already in flight. Unless the user asked NOT to wait, poll leadbay_bulk_enrich_status with this bulk_id for results (see next_action); if they asked not to wait, hand back the bulk_id.",
-              next_action: "Unless the user explicitly asked NOT to wait, poll leadbay_bulk_enrich_status({bulk_id}) until all_done \u2014 OR until overall_progress.done plateaus across spaced polls (~90s\u20132min; unresolvable contacts never flip). include_contacts=true on the read you report from, then report the resolved enrichment in this turn. If the user asked not to wait, hand back the bulk_id instead."
-            };
-          }
-          bulkRecord = {
-            bulk_id: fresh.record.bulk_id,
-            launched_at: fresh.record.launched_at,
-            durability: fresh.record.durability
-          };
-        } else 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,
-            notification_id: res.record.notification_id ?? null,
-            seconds_since_original_launch: bulkSecondsSinceOriginal ?? 0,
-            lead_ids: leadIds,
-            titles,
-            email,
-            phone,
-            preview,
-            message: `No new enrichment was ordered; quota not spent. An identical bulk was launched ${bulkSecondsSinceOriginal ?? 0}s ago. Unless the user asked NOT to wait (background/'I'll check later'), poll leadbay_bulk_enrich_status with this bulk_id for results; if they DID ask not to wait, hand back the bulk_id instead.`,
-            next_action: "Unless the user explicitly asked NOT to wait (background/'I'll check later'), poll leadbay_bulk_enrich_status({bulk_id}) until all_done \u2014 OR until overall_progress.done holds steady across several SPACED polls (~15\u201330s apart, ~90s\u20132min elapsed; unresolvable contacts never flip, so a reused bulk can stay all_done:false forever). include_contacts=true on the read you report from, then report the resolved enrichment in this turn \u2014 don't end your turn waiting or spin forever. If the user DID ask not to wait, hand back the bulk_id instead of polling."
-          };
-        }
-      }
-      ctx?.progress?.({
-        progress: 3,
-        total: 3,
-        message: `Launching enrichment for ${titles.length} title${titles.length === 1 ? "" : "s"}\u2026`
-      });
-      let launchResp = null;
-      try {
-        launchResp = await client.request("POST", "/leads/selection/enrichment/launch", { titles, email, phone });
-      } catch (err) {
-        const aborted = err?.name === "AbortError" || ctx?.signal?.aborted === true;
-        if (bulkRecord && tracker) {
-          try {
-            if (aborted) {
-              await tracker.markCancelled(bulkRecord.bulk_id);
-            } else {
-              await tracker.markFailed(bulkRecord.bulk_id);
-            }
-          } catch (e) {
-            ctx?.logger?.warn?.(`enrich_titles: tracker.${aborted ? "markCancelled" : "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;
-      }
-      const notificationId = launchResp?.notification_id ?? null;
-      if (bulkRecord && tracker) {
-        try {
-          await tracker.markLaunched(bulkRecord.bulk_id, notificationId);
-        } 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,
-            // Surface the resolved lead IDs so the agent can follow the backend
-            // job per-lead — bulk_enrich_status is unusable for this stuck handle,
-            // and the caller may have omitted leadIds (wishlist default), so
-            // without these it has no identifiers to poll.
-            lead_ids: leadIds,
-            titles,
-            email,
-            phone,
-            message: "Enrichment job launched on the backend, but the local tracker record could not be flipped to 'launched' and will NOT heal on its own this session. leadbay_bulk_enrich_status({bulk_id}) will keep returning status:'pending' (BULK_PENDING) \u2014 do NOT poll it in a loop expecting completion. The backend job is running regardless; track it per-lead instead.",
-            next_action: "Do NOT poll leadbay_bulk_enrich_status \u2014 this bulk_id is stuck 'pending' and won't flip. If the user asked NOT to wait (background/'I'll check later'), just hand back the returned lead_ids and let them re-check later. Otherwise track results per lead via leadbay_get_contacts(leadId) / leadbay_research_lead_by_id for the returned lead_ids (re-check every ~30s). get_contacts returns each lead's FULL contact list, so only count/report contacts whose job_title matches the enriched titles (" + titles.join(", ") + ") \u2014 don't attribute a pre-existing CFO/Sales email to this run \u2014 and a contact is done only when the REQUESTED channel landed (requested email and/or phone_number present, not contact.enrichment.done alone). Stop once the done set plateaus (~90s\u20132min), then report the resolved contacts and name the rest. (The launch already succeeded \u2014 do not relaunch.)"
-          };
-        }
-      }
+  const fingerprint = launchFingerprint([
+    "enrich",
+    leadIds,
+    titles,
+    email,
+    phone,
+    lensId
+  ]);
+  const claim = beginLaunch(fingerprint);
+  if (claim.state === "in_flight") {
+    return {
+      mode: "launch_in_flight",
+      launched: false,
+      preview,
+      lead_ids: leadIds,
+      titles,
+      message: `An identical enrichment was started ${claim.seconds_since}s ago and has not returned its job id yet. Nothing was launched twice and no quota was spent.`,
+      next_action: "Wait a few seconds and call leadbay_enrich_titles again with the same arguments \u2014 it will hand back the job id once the first call settles. Do not treat this as a running job; there is no id to poll yet."
+    };
+  }
+  const already = claim.state === "settled" ? claim.record : void 0;
+  if (already) {
+    return {
+      mode: "already_launched",
+      launched: true,
+      preview,
+      reused: true,
+      seconds_since_original_launch: already.seconds_since,
+      lead_ids: leadIds,
+      titles,
+      email,
+      phone,
+      notification_id: already.notification_id,
+      launched_at: already.launched_at,
+      message: `An identical enrichment was launched ${already.seconds_since}s ago; this call did NOT spend quota again. Poll the original job rather than relaunching.`,
+      next_action: "Poll leadbay_bulk_enrich_status({notification_id, lead_ids, titles, email, phone, include_contacts: true}) until all_done, or until overall_progress.done holds steady across spaced polls (~15-30s apart) \u2014 unresolvable contacts never flip. Pass titles/email/phone every time: they scope counting to the roles and channel THIS run asked for, so a contact enriched earlier cannot report the run as finished. Then report what landed and name what didn't."
+    };
+  }
+  ctx?.progress?.({
+    progress: 3,
+    total: 3,
+    message: `Launching enrichment for ${titles.length} title${titles.length === 1 ? "" : "s"}\u2026`
+  });
+  let launchResp = null;
+  try {
+    launchResp = await client.request("POST", "/leads/selection/enrichment/launch", { titles, email, phone });
+  } catch (err) {
+    abandonLaunch(fingerprint);
+    if (err?.code === "QUOTA_EXCEEDED") {
       return {
-        mode: "launched",
+        status: "quota_exceeded",
         preview,
-        launched: true,
-        titles,
-        email,
-        phone,
-        // Always surface the resolved lead IDs — in the no-tracker branch there's
-        // no bulk_id to poll, and the caller may have omitted leadIds (wishlist
-        // default), so without these the agent has no identifiers to follow the
-        // job it just launched via leadbay_get_contacts / research_lead_by_id.
-        lead_ids: leadIds,
-        bulk_id: bulkRecord?.bulk_id,
-        launched_at: bulkRecord?.launched_at,
-        durability: bulkRecord?.durability,
-        notification_id: notificationId,
-        // Branch on bulkRecord FIRST: leadbay_bulk_enrich_status needs a real
-        // bulk_id (tracker handle). A notification_id can come back even with no
-        // tracker (legacy / OpenClaw raw-launch fall-through) — in that case
-        // bulk_id is undefined, so the agent must use the per-lead fallback, not
-        // poll a nonexistent bulk_id.
-        message: bulkRecord ? notificationId ? "Enrichment job launched (runs async). Unless the user asked NOT to wait (background/'I'll check later'), do NOT end your turn here \u2014 poll leadbay_bulk_enrich_status({bulk_id}) until all_done OR until progress plateaus (overall_progress.done stops climbing across spaced polls \u2014 unresolvable contacts keep all_done:false forever), then report the finished contacts yourself. (If the user DID ask not to wait, hand back the bulk_id instead. Either way, if you leave the conversation the completion also surfaces later via _meta.notifications / leadbay_account_status.notifications \u2014 but for a job you launched this turn and were NOT told to background, poll it now.)" : "Enrichment job launched (runs async). Unless the user asked NOT to wait (background/'I'll check later'), do NOT end your turn here \u2014 poll leadbay_bulk_enrich_status({bulk_id}) until all_done OR until progress plateaus (overall_progress.done stops climbing across spaced polls \u2014 unresolvable contacts keep all_done:false forever), then report the finished contacts yourself. (No notification id was returned, so there is NO automatic _meta.notifications completion for this job \u2014 if you background it or don't finish this turn, you (or the user) must poll leadbay_bulk_enrich_status({bulk_id}) again later; it will NOT surface on its own.)" : "Enrichment job launched. No bulk_id tracker configured. Unless the user asked NOT to wait (background/'I'll check later' \u2014 in which case hand back the lead_ids and let them re-check later), poll leadbay_get_contacts per lead (re-check every ~30s). get_contacts returns each lead's FULL contact list, so only count/report contacts whose job_title matches the enriched titles (" + titles.join(", ") + ") \u2014 don't attribute a pre-existing email of an unrelated role to this run \u2014 and a contact is done only when the REQUESTED channel landed (requested email and/or phone_number present, not contact.enrichment.done alone). Then report the results. Stop once the set of done contacts stops growing across a couple of spaced re-checks (~90s\u20132min elapsed): some contacts are unresolvable and never flip, so report the resolved ones and name the rest rather than polling forever.",
-        next_action: bulkRecord ? "Unless the user explicitly asked NOT to wait (background/'I'll check later'), poll leadbay_bulk_enrich_status({bulk_id}) in a loop until all_done \u2014 OR until overall_progress.done holds steady across several SPACED polls (~15\u201330s apart, ~90s\u20132min elapsed; don't call a plateau from the first back-to-back reads while the backend spins up, and don't call it a plateau while partial_failures is present \u2014 that's a transient fetch error, keep polling/respect retry_after). Pass include_contacts=true on the read you report from, then report the resolved enrichment in THIS turn (name what landed and what didn't). If the user DID ask not to wait, hand back the bulk_id instead of polling (and if notification_id is null, tell them to ask again later \u2014 nothing auto-surfaces)." : "Unless the user asked not to wait, re-check via leadbay_research_lead_by_id or leadbay_get_contacts for the returned lead_ids (every ~30s). get_contacts returns each lead's FULL contact list, so only count/report contacts whose job_title matches the enriched titles (" + titles.join(", ") + ") \u2014 don't attribute a pre-existing email of an unrelated role to this run. Treat a contact as done only when the REQUESTED channel landed \u2014 the requested email present and/or phone_number present \u2014 NOT contact.enrichment.done alone (it's already true for a contact enriched on the other channel earlier). Stop once the done set stops growing across a couple of spaced re-checks (~90s\u20132min elapsed) \u2014 unresolvable contacts never flip \u2014 then report the resolved ones and name the rest. Don't poll forever or end your turn waiting. If the user asked not to wait, hand back the lead_ids and let them re-check later."
+        message: "Quota exceeded on launch",
+        retry_after_seconds: err?._meta?.retry_after ?? null
       };
     }
+    throw err;
   }
+  const notificationId = launchResp?.notification_id ?? null;
+  const remembered = rememberLaunch(fingerprint, notificationId);
+  return {
+    mode: "launched",
+    preview,
+    launched: true,
+    titles,
+    email,
+    phone,
+    // Always surfaced: these are the coordinates the agent polls with. There is
+    // no server-side handle to look them up from, by design.
+    lead_ids: leadIds,
+    notification_id: notificationId,
+    launched_at: remembered.launched_at,
+    message: notificationId ? "Enrichment job launched (runs async). Unless the user asked NOT to wait, do NOT end your turn here \u2014 poll leadbay_bulk_enrich_status({notification_id, lead_ids, titles, email, phone}) until all_done OR until progress plateaus (overall_progress.done stops climbing across spaced polls \u2014 unresolvable contacts keep all_done:false forever), then report the finished contacts yourself. The notification_id keeps working across conversations and days; completion also surfaces via _meta.notifications / leadbay_account_status.notifications." : "Enrichment job launched, but the backend returned no notification_id, so there is no job id to poll. Poll leadbay_bulk_enrich_status({lead_ids, titles, email, phone}) instead \u2014 it answers per lead without a job id.",
+    next_action: notificationId ? "Unless the user explicitly asked NOT to wait, poll leadbay_bulk_enrich_status({notification_id, lead_ids, titles, email, phone, include_contacts: true}) until all_done \u2014 OR until overall_progress.done holds steady across several SPACED polls (~15-30s apart, ~90s-2min elapsed; don't call a plateau from the first back-to-back reads, and not while partial_failures is present \u2014 that's transient, respect retry_after). Carry titles/email/phone on every poll \u2014 they scope counting to the roles and channel THIS run asked for, and without them a contact enriched months ago counts as done and all_done flips true before anything landed. Then report the resolved enrichment in THIS turn, naming what landed and what didn't. If the user DID ask not to wait, hand back the notification_id \u2014 it resolves later from any conversation." : "Poll leadbay_bulk_enrich_status({lead_ids, titles, email, phone, include_contacts: true}) every ~30s. It scopes counting to these titles and treats a contact as done only when the REQUESTED channel landed, so you do not have to do that yourself. Stop once overall_progress.done stops growing across a couple of spaced re-checks (~90s-2min) \u2014 unresolvable contacts never flip."
+  };
 }
 async function launchEnrichment(client, args, ctx) {
   await client.acquireSelectionLock();
@@ -19137,6 +18697,7 @@ var DEFAULT_CANDIDATE_COUNT, enrichTitles;
 var init_enrich_titles = __esm({
   "../core/dist/composite/enrich-titles.js"() {
     "use strict";
+    init_launch_guard();
     init_credits_helpers();
     init_tool_descriptions_generated();
     DEFAULT_CANDIDATE_COUNT = 25;
@@ -19150,7 +18711,7 @@ var init_enrich_titles = __esm({
         // destructive because the dominant flow mutates state.
         destructiveHint: true,
         // Idempotent against the same selection + titles set (same hash → same
-        // bulk_id; backend silently no-ops on already-enriched contacts).
+        // the launch; backend silently no-ops on already-enriched contacts).
         idempotentHint: true,
         openWorldHint: true
       },
@@ -19191,11 +18752,11 @@ var init_enrich_titles = __esm({
       },
       outputSchema: {
         type: "object",
-        description: "Branchy return shape; the `mode` (or `status`) field tells the agent which branch it got. Modes: 'discover' (no titles passed), 'preview_only' (no enrichable contacts), 'dry_run', 'needs_confirmation' (paid launch withheld pending user consent), 'already_launched' (idempotent reuse), 'launched_tracker_pending' (rare, soft-fail), 'launched' (happy path). Status: 'quota_exceeded' (429).",
+        description: "Branchy return shape; the `mode` (or `status`) field tells the agent which branch it got. Modes: 'discover' (no titles passed), 'preview_only' (no enrichable contacts), 'dry_run', 'needs_confirmation' (paid launch withheld pending user consent), 'already_launched' (idempotent reuse), 'launch_in_flight' (an identical launch is mid-flight and has no id yet), 'launched' (happy path). Status: 'quota_exceeded' (429).",
         properties: {
           mode: {
             type: "string",
-            description: "'discover' | 'preview_only' | 'dry_run' | 'needs_confirmation' | 'already_launched' | 'launched_tracker_pending' | 'launched'."
+            description: "'discover' | 'preview_only' | 'dry_run' | 'needs_confirmation' | 'already_launched' | 'launch_in_flight' | 'launched'."
           },
           status: {
             type: "string",
@@ -19245,22 +18806,23 @@ var init_enrich_titles = __esm({
             type: "object",
             description: "What dry_run WOULD have launched (titles, email, phone)."
           },
-          re_used: {
-            type: "boolean",
-            description: "True when an identical bulk was launched within the idempotency window (already_launched mode)."
+          notification_id: {
+            type: ["string", "null"],
+            description: "The backend's job id. Carry it to leadbay_bulk_enrich_status. Null when the backend returned none \u2014 then poll by lead_ids instead."
           },
-          bulk_id: {
-            type: "string",
-            description: "UUIDv4 to poll via leadbay_bulk_enrich_status."
+          lead_ids: {
+            type: "array",
+            description: "The leads this run enriched. Carry them to leadbay_bulk_enrich_status for per-lead progress; they also work when the notification is archived.",
+            items: { type: "string" }
+          },
+          reused: {
+            type: "boolean",
+            description: "True when an identical launch inside the 5-minute window was reused instead of spending quota again."
           },
           launched_at: {
             type: "string",
             description: "ISO timestamp of the (re-used or fresh) launch."
           },
-          durability: {
-            type: "string",
-            description: "'file' (persisted bulks.json) or 'memory'."
-          },
           seconds_since_original_launch: {
             type: "number",
             description: "Age of the re-used bulk record (already_launched mode)."
@@ -19519,14 +19081,6 @@ var init_enrich_titles = __esm({
 });
 
 // ../core/dist/composite/bulk-enrich-status.js
-async function readNotification2(client, notificationId) {
-  try {
-    const page = await client.listNotifications({ archived: false, count: 50 });
-    return page.items.find((n) => n.id === notificationId) ?? null;
-  } catch {
-    return null;
-  }
-}
 async function pMap(items, fn, concurrency) {
   const out = new Array(items.length);
   let next = 0;
@@ -19545,8 +19099,9 @@ var STATUS_FETCH_CONCURRENCY, bulkEnrichStatus;
 var init_bulk_enrich_status = __esm({
   "../core/dist/composite/bulk-enrich-status.js"() {
     "use strict";
+    init_read_by_id();
+    init_revise_hint();
     init_get_contacts();
-    init_bulk_store();
     init_credits_helpers();
     init_tool_descriptions_generated();
     STATUS_FETCH_CONCURRENCY = 5;
@@ -19563,44 +19118,45 @@ var init_bulk_enrich_status = __esm({
       inputSchema: {
         type: "object",
         properties: {
-          bulk_id: {
+          notification_id: {
             type: "string",
-            description: "UUIDv4 returned by leadbay_enrich_titles at launch time. Required."
+            description: "The `notification_id` returned by leadbay_enrich_titles. Gives the job-level counters in one call."
+          },
+          lead_ids: {
+            type: "array",
+            description: "The `lead_ids` the launch returned. Gives per-lead progress, and answers on its own if the notification is archived or has aged off page 1.",
+            items: { type: "string" }
+          },
+          titles: {
+            type: "array",
+            description: "The `titles` the launch returned. Scopes progress to the roles THIS run enriched, so a lead's pre-existing CFO email cannot inflate a CEO run.",
+            items: { type: "string" }
+          },
+          email: {
+            type: "boolean",
+            description: "The `email` flag the launch returned. A contact counts as done only once the requested channel has landed."
+          },
+          phone: {
+            type: "boolean",
+            description: "The `phone` flag the launch returned. Same rule as `email`."
           },
           include_contacts: {
             type: "boolean",
             description: "If true, return the full contact list per lead (email, phone, enrichment.done). Default false \u2014 cheap status polls."
           }
         },
-        required: ["bulk_id"],
+        anyOf: [{ required: ["notification_id"] }, { required: ["lead_ids"] }],
         additionalProperties: false
       },
       outputSchema: {
         type: "object",
         properties: {
-          bulk_id: { type: "string", description: "Echoed UUIDv4 handle." },
+          notification_id: { type: "string", description: "The backend job id; pass it back to poll again." },
           launched_at: { type: "string", description: "ISO timestamp of /enrichment/launch ack." },
           status: {
             type: "string",
             description: "'launched' on success. Errors return error envelopes (handled separately)."
           },
-          durability: {
-            type: "string",
-            description: "'persistent' (file-backed bulks.json) or 'memory' (LEADBAY_BULK_STORE_ALLOW_MEMORY)."
-          },
-          titles: {
-            type: "array",
-            description: "Titles ordered at launch time (echoed from the original enrich_titles call).",
-            items: { type: "string" }
-          },
-          email: { type: "boolean", description: "True if email enrichment was requested." },
-          phone: { type: "boolean", description: "True if phone enrichment was requested." },
-          lens_id: { type: "number", description: "Lens id used to scope the enrichment." },
-          leads: {
-            type: "array",
-            description: "Per-lead rollup: {lead_id, enrichment_progress:{done,total}, contacts? (when include_contacts=true)}.",
-            items: { type: "object" }
-          },
           overall_progress: {
             type: "object",
             description: "Aggregate progress across all leads.",
@@ -19624,243 +19180,180 @@ var init_bulk_enrich_status = __esm({
             items: { type: "object" }
           }
         },
-        required: ["bulk_id", "status", "leads", "overall_progress", "all_done"]
+        required: ["status", "leads", "overall_progress", "all_done"]
       },
       execute: async (client, params, ctx) => {
-        if (!isValidBulkId(params.bulk_id)) {
-          return {
-            error: true,
-            code: "BULK_INVALID_ID",
-            message: "bulk_id is not a valid UUIDv4",
-            hint: "Pass the bulk_id returned by leadbay_enrich_titles verbatim."
-          };
-        }
-        if (!ctx?.bulkTracker) {
-          return {
-            error: true,
-            code: "BULK_TRACKER_UNAVAILABLE",
-            message: "No BulkTracker configured on this MCP instance",
-            hint: "This composite requires a BulkTracker in ToolContext. Upgrade to @leadbay/mcp \u22650.3.0 or run with LEADBAY_BULK_STORE_ALLOW_MEMORY=1."
-          };
-        }
         const includeContacts = params.include_contacts ?? false;
+        const leadIds = params.lead_ids ?? [];
         const startMs = Date.now();
-        let record;
-        try {
-          record = await ctx.bulkTracker.get(params.bulk_id);
-        } catch (err) {
-          return {
-            error: true,
-            code: "BULK_STORE_UNAVAILABLE",
-            message: `Bulk store read failed: ${err?.message ?? err}`,
-            hint: "Check the file at $LEADBAY_BULK_STORE_PATH (default ~/.leadbay/bulks.json). Set LEADBAY_BULK_STORE_ALLOW_MEMORY=1 to fall back to in-memory storage on startup (handles won't survive restart)."
-          };
-        }
-        if (!record) {
-          return {
-            error: true,
-            code: "BULK_NOT_FOUND",
-            message: "No bulk record for that bulk_id",
-            hint: "The record may have aged out (30-day TTL) or the MCP process was restarted without persistence. Launch a new enrichment via leadbay_enrich_titles."
-          };
-        }
-        if (record.kind !== "enrich") {
-          return {
-            error: true,
-            code: "BULK_WRONG_KIND",
-            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
-          };
-        }
-        if (record.status === "pending") {
-          return {
-            error: true,
-            code: "BULK_PENDING",
-            message: "Bulk is in 'pending' state \u2014 the launch is in flight or the MCP crashed between launch and ack.",
-            hint: "Retry leadbay_bulk_enrich_status in a few seconds. If it persists >60s, relaunch via leadbay_enrich_titles.",
-            bulk_id: record.bulk_id,
-            launched_at: record.launched_at
-          };
-        }
-        if (record.status === "failed") {
-          return {
-            error: true,
-            code: "BULK_LAUNCH_FAILED",
-            message: "The original /enrichment/launch POST failed; no backend enrichment was ordered.",
-            hint: "Call leadbay_enrich_titles again \u2014 the failed record won't block a fresh launch.",
-            bulk_id: record.bulk_id,
-            launched_at: record.launched_at
-          };
-        }
-        if (record.status === "cancelled") {
+        if (!params.notification_id && leadIds.length === 0) {
           return {
             error: true,
-            code: "BULK_CANCELLED",
-            message: "The bulk was cancelled (ctx.signal aborted by the client mid-launch). No further work is in flight.",
-            hint: "Call leadbay_enrich_titles again with the same titles to relaunch \u2014 the cancelled record won't block a fresh launch.",
-            bulk_id: record.bulk_id,
-            launched_at: record.launched_at
+            code: "ENRICH_STATUS_INPUT_REQUIRED",
+            message: "Pass notification_id and/or lead_ids",
+            hint: "Both are in the leadbay_enrich_titles result. notification_id gives the job counters; lead_ids gives per-lead progress and works even when the notification has been archived."
           };
         }
-        const notifId = record.notification_id ?? null;
-        if (notifId) {
-          const n = await readNotification2(client, notifId);
-          if (n && n.bulk_progress) {
-            const bp = n.bulk_progress;
-            const inProgress = n.in_progress;
-            let leads2 = [];
-            const fastPartialFailures = [];
-            if (includeContacts) {
-              leads2 = await pMap(record.lead_ids, async (leadId) => {
-                try {
-                  const out = await getContacts.execute(client, { leadId });
-                  const contacts = Array.isArray(out?.contacts) ? out.contacts : [];
-                  const fe = Array.isArray(out?._fetch_errors) ? out._fetch_errors : [];
-                  if (fe.length > 0) {
-                    fastPartialFailures.push({
-                      lead_id: leadId,
-                      code: fe[0]?.code ?? "FETCH_ERROR",
-                      ...fe[0]?.retry_after !== void 0 ? { retry_after: fe[0].retry_after } : {}
-                    });
-                  }
-                  return { lead_id: leadId, contacts };
-                } catch (err) {
-                  fastPartialFailures.push({
-                    lead_id: leadId,
-                    code: err?.code ?? "UNKNOWN",
-                    ...err?._meta?.retry_after !== void 0 ? { retry_after: err._meta.retry_after } : {}
-                  });
-                  return { lead_id: leadId };
-                }
-              }, STATUS_FETCH_CONCURRENCY);
-            } else {
-              leads2 = record.lead_ids.map((id) => ({ lead_id: id }));
-            }
-            ctx?.logger?.info?.(`bulk.status_checked_via_notification bulk_id=${record.bulk_id} notification_id=${notifId} done=${bp.success_count}/${bp.total_count} in_progress=${inProgress} wall_ms=${Date.now() - startMs}`);
-            const isReportRead = !inProgress || includeContacts;
-            const creditsRemaining2 = isReportRead ? await readCreditsRemaining(client, true) : null;
+        let bp = null;
+        let inProgress = null;
+        let launchedAt = null;
+        if (params.notification_id) {
+          const n = await readNotificationById(client, params.notification_id);
+          if (n && inferKind(n) !== "bulk_enrich") {
+            const kind = inferKind(n);
             return {
-              bulk_id: record.bulk_id,
-              notification_id: notifId,
-              launched_at: record.launched_at,
-              status: record.status,
-              durability: record.durability,
-              titles: record.titles,
-              email: record.email,
-              phone: record.phone,
-              lens_id: record.lens_id,
-              leads: leads2,
-              overall_progress: {
-                done: bp.success_count + bp.failure_count + bp.quota_hit_count,
-                total: bp.total_count,
-                done_ratio: bp.total_count === 0 ? 0 : (bp.success_count + bp.failure_count + bp.quota_hit_count) / bp.total_count
-              },
-              bulk_progress: bp,
-              in_progress: inProgress,
-              all_done: !inProgress,
-              ...fastPartialFailures.length > 0 ? { partial_failures: fastPartialFailures } : {},
-              ...isReportRead ? { credits_remaining: creditsRemaining2 } : {},
-              ...bp.quota_hit_count > 0 ? {
-                quota_hit_hint: "Some contacts could not be enriched because the AI-credits quota was hit. Top up via leadbay_create_topup_link or wait for the window reset."
-              } : {}
+              error: true,
+              code: "ENRICH_JOB_WRONG_KIND",
+              message: `That notification_id is a ${kind === "bulk_qualify" ? "lead qualification" : kind === "import" ? "file import" : "non-bulk"} notification, not a contact enrichment`,
+              hint: kind === "bulk_qualify" ? "Poll it with leadbay_qualify_status({notification_id}) instead." : kind === "import" ? "Poll it with leadbay_import_status({importIds}) instead \u2014 the import ids came back from the import launch." : "Pass the notification_id returned by leadbay_enrich_titles."
             };
           }
-          ctx?.logger?.info?.(`bulk_enrich_status: notification ${notifId} not yet visible; falling back to per-lead fan-out`);
-        }
-        let doneSoFar = 0;
-        const totalLeads = record.lead_ids.length;
-        const results = await pMap(record.lead_ids, async (leadId) => {
-          try {
-            const out = await getContacts.execute(client, { leadId });
-            const contacts = Array.isArray(out?.contacts) ? out.contacts : [];
-            const wantTitles = new Set((record.titles ?? []).map((t) => t.trim().toLowerCase()));
-            const enrichable = contacts.filter((c) => c && c.enrichment && (wantTitles.size === 0 || typeof c.job_title === "string" && wantTitles.has(c.job_title.trim().toLowerCase())));
-            const channelResolved = (c) => {
-              if (c.enrichment?.done !== true)
-                return false;
-              if (record.email && !c.email)
-                return false;
-              if (record.phone && !c.phone_number)
-                return false;
-              return true;
-            };
-            const done = enrichable.filter(channelResolved).length;
-            const total = enrichable.length;
-            doneSoFar += 1;
-            ctx?.progress?.({
-              progress: doneSoFar,
-              total: totalLeads,
-              message: `Fetched contacts for ${leadId} (${doneSoFar}/${totalLeads})`
-            });
-            return {
-              kind: "ok",
-              lead_id: leadId,
-              done,
-              total,
-              contacts: includeContacts ? contacts : void 0
-            };
-          } catch (err) {
-            doneSoFar += 1;
-            ctx?.progress?.({
-              progress: doneSoFar,
-              total: totalLeads,
-              message: `Fetch failed for ${leadId} (${doneSoFar}/${totalLeads}): ${err?.code ?? "UNKNOWN"}`
-            });
+          if (n) {
+            bp = n.bulk_progress;
+            inProgress = n.in_progress;
+            launchedAt = n.created_at;
+          } else if (leadIds.length === 0) {
             return {
-              kind: "fail",
-              lead_id: leadId,
-              code: err?.code ?? "UNKNOWN",
-              retry_after: err?._meta?.retry_after
+              error: true,
+              code: "ENRICH_JOB_NOT_FOUND",
+              message: "That notification_id is not in the recent notification list",
+              hint: "The lookup scans your recent unarchived notifications; an archived job, or one behind many newer ones, will not be found. Re-call with the `lead_ids` the launch returned \u2014 that answers without the notification."
             };
           }
-        }, STATUS_FETCH_CONCURRENCY);
-        const leads = [];
-        const partialFailures = [];
-        let totalDone = 0;
-        let totalAll = 0;
-        for (const r of results) {
-          if (r.kind === "fail") {
-            partialFailures.push({
+        }
+        if (leadIds.length > 0) {
+          const wantTitles = new Set((params.titles ?? []).map((t) => t.trim().toLowerCase()));
+          const channelResolved = (c) => {
+            if (c?.enrichment?.done !== true)
+              return false;
+            if (params.email && !c.email)
+              return false;
+            if (params.phone && !c.phone_number)
+              return false;
+            return true;
+          };
+          let doneSoFar = 0;
+          const totalLeads = leadIds.length;
+          const results = await pMap(leadIds, async (leadId) => {
+            try {
+              const out = await getContacts.execute(client, { leadId });
+              const contacts = Array.isArray(out?.contacts) ? out.contacts : [];
+              const enrichable = contacts.filter((c) => c && c.enrichment && (wantTitles.size === 0 || typeof c.job_title === "string" && wantTitles.has(c.job_title.trim().toLowerCase())));
+              const fe = Array.isArray(out?._fetch_errors) ? out._fetch_errors : [];
+              doneSoFar += 1;
+              ctx?.progress?.({
+                progress: doneSoFar,
+                total: totalLeads,
+                message: `Fetched contacts for ${leadId} (${doneSoFar}/${totalLeads})`
+              });
+              if (fe.length > 0) {
+                return {
+                  kind: "fail",
+                  lead_id: leadId,
+                  code: fe[0]?.code ?? "FETCH_ERROR",
+                  ...fe[0]?.retry_after !== void 0 ? { retry_after: fe[0].retry_after } : {}
+                };
+              }
+              return {
+                kind: "ok",
+                lead_id: leadId,
+                done: enrichable.filter(channelResolved).length,
+                total: enrichable.length,
+                ...includeContacts ? { contacts } : {}
+              };
+            } catch (err) {
+              doneSoFar += 1;
+              ctx?.progress?.({
+                progress: doneSoFar,
+                total: totalLeads,
+                message: `Fetch failed for ${leadId} (${doneSoFar}/${totalLeads}): ${err?.code ?? "UNKNOWN"}`
+              });
+              return {
+                kind: "fail",
+                lead_id: leadId,
+                code: err?.code ?? "UNKNOWN",
+                ...err?._meta?.retry_after !== void 0 ? { retry_after: err._meta.retry_after } : {}
+              };
+            }
+          }, STATUS_FETCH_CONCURRENCY);
+          const leads = [];
+          const partialFailures = [];
+          let totalDone = 0;
+          let totalAll = 0;
+          for (const r of results) {
+            if (r.kind === "fail") {
+              partialFailures.push({
+                lead_id: r.lead_id,
+                code: r.code,
+                ...r.retry_after !== void 0 ? { retry_after: r.retry_after } : {}
+              });
+              continue;
+            }
+            leads.push({
               lead_id: r.lead_id,
-              code: r.code,
-              ...r.retry_after !== void 0 ? { retry_after: r.retry_after } : {}
+              ...r.contacts ? { contacts: r.contacts } : {},
+              enrichment_progress: { done: r.done, total: r.total }
             });
-            continue;
+            totalDone += r.done;
+            totalAll += r.total;
           }
-          leads.push({
-            lead_id: r.lead_id,
-            ...r.contacts ? { contacts: r.contacts } : {},
-            enrichment_progress: { done: r.done, total: r.total }
-          });
-          totalDone += r.done;
-          totalAll += r.total;
+          const allDone = totalAll > 0 && totalDone === totalAll && partialFailures.length === 0;
+          ctx?.logger?.info?.(`bulk.status leads=${leadIds.length} done=${totalDone}/${totalAll} wall_ms=${Date.now() - startMs}`);
+          const creditsRemaining2 = allDone ? await readCreditsRemaining(client, true) : null;
+          return {
+            ...params.notification_id ? { notification_id: params.notification_id } : {},
+            ...launchedAt ? { launched_at: launchedAt } : {},
+            status: allDone ? "complete" : "launched",
+            // Echo what was asked for, so the reply states its own scope.
+            ...params.titles ? { titles: params.titles } : {},
+            ...params.email !== void 0 ? { email: params.email } : {},
+            ...params.phone !== void 0 ? { phone: params.phone } : {},
+            leads,
+            overall_progress: {
+              done: totalDone,
+              total: totalAll,
+              done_ratio: totalAll === 0 ? 0 : totalDone / totalAll
+            },
+            ...bp ? { bulk_progress: bp } : {},
+            ...inProgress !== null ? { in_progress: inProgress } : {},
+            all_done: allDone,
+            ...partialFailures.length > 0 ? { partial_failures: partialFailures } : {},
+            ...allDone ? { credits_remaining: creditsRemaining2 } : {},
+            ...bp && bp.quota_hit_count > 0 ? {
+              quota_hit_hint: "Some contacts could not be enriched because the AI-credits quota was hit. Top up via leadbay_create_topup_link or wait for the window reset."
+            } : {}
+          };
         }
-        const overallProgress = {
-          done: totalDone,
-          total: totalAll,
-          done_ratio: totalAll === 0 ? 0 : totalDone / totalAll
-        };
-        const allDone = totalAll > 0 && totalDone === totalAll && partialFailures.length === 0;
-        ctx?.logger?.info?.(`bulk.status_checked bulk_id=${record.bulk_id} done=${totalDone} total=${totalAll} wall_ms=${Date.now() - startMs}`);
-        let creditsRemaining = null;
-        if (allDone) {
-          creditsRemaining = await readCreditsRemaining(client, true);
+        if (!bp) {
+          return {
+            error: true,
+            code: "ENRICH_JOB_NO_COUNTERS",
+            message: `This enrichment notification carries no per-contact counters; the backend reports it as ${inProgress ? "still running" : "finished"}`,
+            hint: "Re-call with the `lead_ids` returned by leadbay_enrich_titles (plus titles/email/phone) \u2014 that path counts contacts directly and works whether or not the notification has counters.",
+            ...inProgress !== null ? { in_progress: inProgress } : {},
+            ...launchedAt ? { launched_at: launchedAt } : {}
+          };
         }
+        const done = bp.success_count + bp.failure_count + bp.quota_hit_count;
+        const isReportRead = !inProgress;
+        const creditsRemaining = isReportRead ? await readCreditsRemaining(client, true) : null;
         return {
-          bulk_id: record.bulk_id,
-          launched_at: record.launched_at,
-          status: record.status,
-          durability: record.durability,
-          titles: record.titles,
-          email: record.email,
-          phone: record.phone,
-          lens_id: record.lens_id,
-          leads,
-          overall_progress: overallProgress,
-          all_done: allDone,
-          ...allDone ? { credits_remaining: creditsRemaining } : {},
-          ...partialFailures.length > 0 ? { partial_failures: partialFailures } : {}
+          notification_id: params.notification_id,
+          launched_at: launchedAt,
+          status: inProgress ? "launched" : "complete",
+          leads: [],
+          overall_progress: {
+            done,
+            total: bp.total_count,
+            done_ratio: bp.total_count === 0 ? 0 : done / bp.total_count
+          },
+          bulk_progress: bp,
+          in_progress: inProgress,
+          all_done: !inProgress,
+          ...isReportRead ? { credits_remaining: creditsRemaining } : {},
+          ...bp.quota_hit_count > 0 ? {
+            quota_hit_hint: "Some contacts could not be enriched because the AI-credits quota was hit. Top up via leadbay_create_topup_link or wait for the window reset."
+          } : {}
         };
       }
     };
@@ -21991,7 +21484,7 @@ var init_artifact_runtime_generated = __esm({
   "../core/dist/artifact-runtime.generated.js"() {
     "use strict";
     ARTIFACT_KIT_VERSION = "0.5.0";
-    ARTIFACT_RUNTIME = '"use strict";(()=>{var L=Object.defineProperty;var A=(e,r,t)=>r in e?L(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var a=(e,r,t)=>A(e,typeof r!="symbol"?r+"":r,t);var S=`\n:root{\n--color-black:#191919;--color-white:#fff;\n--color-gray-1:#f9f9f9;--color-gray-2:#f0f0f0;--color-gray-3:#e0e0e0;--color-gray-4:#cecece;\n--color-gray-5:#c4c4c4;--color-gray-6:#8d8d8d;--color-gray-7:#787878;--color-gray-8:#646464;\n--color-gray-9:#202020;\n--color-linkedin:#0a66c2;\n--color-blue-background:oklch(0.947 0.029 251);--color-blue-foreground:oklch(0.564 0.181 251);\n--color-green-background:oklch(0.947 0.029 141);--color-green-foreground:oklch(0.564 0.181 141);\n--color-red-background:oklch(0.947 0.029 26);--color-red-foreground:oklch(0.564 0.191 26);\n--color-gold-background:oklch(0.972 0.049 91);--color-gold-foreground:oklch(0.667 0.177 91);\n--color-cherry-background:oklch(0.947 0.029 15);--color-cherry-foreground:oklch(0.44 0.146 15);\n--color-red-like:var(--color-cherry-foreground);\n--lb-font:"Nikkei Maru",system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;\n--lb-radius:1rem;--lb-radius-sm:0.625rem;--lb-gap:0.75rem;\n--lb-surface:var(--color-gray-1);--lb-border:var(--color-gray-3);\n--lb-fg:var(--color-black);--lb-muted:var(--color-gray-8);--lb-field:var(--color-white);\n}\n:root[data-theme=dark],:root[data-lb-theme=dark]{\n--lb-surface:var(--color-gray-9);--lb-border:var(--color-gray-8);\n--lb-fg:var(--color-white);--lb-muted:var(--color-gray-3);--lb-field:var(--color-gray-9);\n}\n@media(prefers-color-scheme:dark){:root:not([data-theme=light]):not([data-lb-theme=light]){\n--lb-surface:var(--color-gray-9);--lb-border:var(--color-gray-8);\n--lb-fg:var(--color-white);--lb-muted:var(--color-gray-3);--lb-field:var(--color-gray-9);\n}}\n.lb-card{display:grid;gap:var(--lb-gap);padding:0.875rem;\nbackground-color:var(--lb-surface);border:1px solid var(--lb-border);\nborder-radius:var(--lb-radius);corner-shape:squircle;color:var(--lb-fg);\nfont-family:var(--lb-font);\nbox-shadow:0 1rem 2.5rem color-mix(in srgb,var(--color-gray-9) 6%,transparent),\n0 0.125rem 0.5rem color-mix(in srgb,var(--color-gray-9) 4%,transparent)}\n.lb-card-head{display:flex;justify-content:space-between;align-items:baseline;gap:var(--lb-gap)}\n.lb-title{font-size:0.875rem;font-weight:600;line-height:1.25rem;color:var(--lb-fg)}\n.lb-sub{font-size:0.8125rem;line-height:1.125rem;color:var(--lb-muted)}\n.lb-row{display:flex;align-items:center;gap:var(--lb-gap);flex-wrap:wrap}\n.lb-stack{display:grid;gap:var(--lb-gap)}\n.lb-select,.lb-input{font:inherit;font-family:var(--lb-font);font-size:0.8125rem;color:var(--lb-fg);\nbackground-color:var(--lb-field);border:1px solid var(--lb-border);\nborder-radius:var(--lb-radius-sm);corner-shape:squircle;padding:0.4rem 0.55rem;min-height:2.125rem}\n.lb-btn{font:inherit;font-family:var(--lb-font);font-size:0.8125rem;font-weight:600;\ncolor:var(--lb-fg);background-color:var(--lb-field);border:1px solid var(--lb-border);\nborder-radius:var(--lb-radius-sm);corner-shape:squircle;padding:0.4rem 0.85rem;min-height:2.125rem;\ncursor:pointer;transition:background-color .15s,border-color .15s,color .15s}\n.lb-btn:hover:not([disabled]){border-color:var(--color-gray-6)}\n.lb-btn:focus-visible,.lb-select:focus-visible,.lb-input:focus-visible{\noutline:2px solid var(--color-blue-foreground);outline-offset:1px}\n.lb-btn[data-lb-state=loading]{opacity:.55;cursor:progress}\n.lb-btn[data-lb-state=success]{background-color:var(--color-green-background);\nborder-color:var(--color-green-foreground);color:var(--color-green-foreground)}\n.lb-btn[data-lb-state=error],.lb-select[data-lb-state=error]{\nbackground-color:var(--color-red-background);border-color:var(--color-red-foreground);\ncolor:var(--color-red-foreground)}\n.lb-btn[data-lb-state=unavailable],.lb-btn[disabled]{opacity:.5;cursor:not-allowed}\n.lb-msg{font-size:0.8125rem;line-height:1.125rem;color:var(--lb-muted)}\n.lb-msg[data-tone=error]{color:var(--color-red-foreground)}\n.lb-msg[data-tone=ok]{color:var(--color-green-foreground)}\n.lb-chip{display:inline-flex;align-items:center;gap:.25rem;white-space:nowrap;\nfont-size:0.75rem;font-weight:600;line-height:1rem;padding:0.125rem 0.5rem;\nborder-radius:var(--lb-radius-sm);corner-shape:squircle;\nbackground-color:var(--color-gray-2);color:var(--lb-muted)}\n.lb-chip[data-status=WANTED]{background-color:var(--color-blue-background);color:var(--color-blue-foreground)}\n.lb-chip[data-status=WON]{background-color:var(--color-green-background);color:var(--color-green-foreground)}\n.lb-chip[data-status=LOST]{background-color:var(--color-red-background);color:var(--color-red-foreground)}\n.lb-chip[data-status=UNWANTED]{background-color:var(--color-gray-2);color:var(--color-gray-7)}\n.lb-chip[data-taste=liked]{background-color:var(--color-cherry-background);color:var(--color-red-like)}\n.lb-chip[data-taste=disliked]{background-color:var(--color-gray-2);color:var(--color-gray-7)}\n.lb-chips{display:flex;align-items:center;gap:.35rem;flex-wrap:wrap}\n.lb-chip[hidden]{display:none}\n.lb-table{width:100%;border-collapse:collapse;font-family:var(--lb-font);color:var(--lb-fg)}\n.lb-table th,.lb-table td{text-align:left;padding:0.5rem 0.4rem;\nborder-bottom:1px solid var(--lb-border);vertical-align:middle;font-size:0.8125rem}\n.lb-table th{font-size:0.75rem;font-weight:600;color:var(--lb-muted);\ntext-transform:uppercase;letter-spacing:.04em}\n.lb-link{color:var(--color-blue-foreground);text-decoration:none}\n.lb-link:hover{text-decoration:underline}\n/* Quiet text link out of the artifact. Button-height so it shares the row\'s\n   baseline; understated so it never competes with the actions beside it. The\n   arrow is a bare diagonal stroke \\u2014 an escape-hatch marker, not an icon that\n   asks to be read. */\n.lb-link-out{display:inline-flex;align-items:center;gap:.3rem;\nfont-size:0.75rem;line-height:1rem;min-height:2.125rem;\ncolor:var(--lb-fg);text-decoration:none;opacity:.65;transition:opacity .15s}\n.lb-link-out:hover{opacity:1;text-decoration:underline}\n.lb-link-out:focus-visible{outline:2px solid var(--color-blue-foreground);outline-offset:1px;\nborder-radius:var(--lb-radius-sm)}\n.lb-link-out svg{width:.85em;height:.85em;flex-shrink:0}\n/* Pushes whatever follows it to the right edge of an .lb-row, so a trailing\n   link sits on the SAME baseline as the row\'s buttons instead of on its own\n   line below them. */\n.lb-spacer{flex:1 1 auto}\n.lb-spinner{display:inline-block;width:.7em;height:.7em;border:2px solid var(--lb-border);\nborder-top-color:var(--color-blue-foreground);border-radius:50%;animation:lb-spin .8s linear infinite}\n@keyframes lb-spin{to{transform:rotate(1turn)}}\n@media(prefers-reduced-motion:reduce){.lb-spinner{animation:none}\n.lb-btn{transition-property:none}}\n`,p="lb-styles";var x="0.5.0",c=class extends Error{constructor(t,o={}){super(t);a(this,"code");a(this,"raw");this.name="LbError",this.code=o.code,this.raw=o.raw}},y=null,f=3e4;function C(){let e=globalThis.cowork;return e&&typeof e.callMcpTool=="function"?(r,t)=>e.callMcpTool(r,t):null}function _(e){if(e&&typeof e=="object"&&"content"in e){let r=e.content;if(Array.isArray(r)&&r[0]&&typeof r[0].text=="string")return r[0].text}return null}function E(e){if(!e||typeof e!="object")return e;let r=e;if(r.isError)throw new c(_(e)??"tool call failed",{raw:e});if("structuredContent"in r&&r.structuredContent!=null)return r.structuredContent;let t=_(e);if(t!=null)try{return JSON.parse(t)}catch{return t}return e}function I(e){return e instanceof Error?e.message:String(e)}function v(e){let r=e instanceof c?e.code:void 0;return{message:I(e),unavailable:r==="unavailable",code:r}}function O(e={}){y=e.call??null,f=e.timeoutMs??3e4}function R(){if(typeof document>"u"||!document.head)return null;let e=document.getElementById(p);if(e)return e;let r=document.createElement("style");return r.id=p,r.textContent=S,document.head.appendChild(r),r}async function T(e,r){if(!f||f<=0)return e;let t,o=new Promise((n,i)=>{t=setTimeout(()=>i(new c(`"${r}" timed out after ${f}ms`,{code:"timeout"})),f)});try{return await Promise.race([e,o])}finally{t&&clearTimeout(t)}}async function l(e,r={}){if(y)return E(await T(Promise.resolve(y(e,r)),e));let t=C();if(!t)throw new c("Leadbay bridge unavailable (window.cowork absent)",{code:"unavailable"});return E(await T(Promise.resolve(t(e,r)),e))}var g=class{constructor(){a(this,"subs",new Set)}subscribe(r){return this.subs.add(r),r(this),()=>this.subs.delete(r)}emit(){for(let r of this.subs)r(this)}};function N(e){return Array.isArray(e)?e.map(r=>r&&typeof r=="object"?r:{value:r,label:String(r)}):[]}var b=class extends g{constructor(t={}){super();a(this,"kind");a(this,"value");a(this,"options",[]);a(this,"loading",!1);a(this,"error",null);a(this,"ready",!1);a(this,"cfg");a(this,"depUnsubs",[]);a(this,"seq",0);this.cfg=t,this.kind=t.kind,this.value=t.value??"";for(let o of t.dependsOn??[]){let n=o.value;this.depUnsubs.push(o.subscribe(()=>{o.value!==n&&(n=o.value,this.cfg.load&&this.load())}))}t.load&&(t.autoLoad??!0)&&this.load()}async load(){if(!this.cfg.load)return;let t=++this.seq;this.loading=!0,this.error=null,this.emit();try{let o=await this.cfg.load();if(t!==this.seq)return;this.options=this.cfg.options?this.cfg.options(o):N(o),this.ready=!0;let n=this.value==null?"":String(this.value);this.options.length&&(n===""||!this.options.some(i=>String(i.value)===n))&&(this.value=this.options[0].value)}catch(o){if(t!==this.seq)return;this.options=[],this.error=v(o)}finally{t===this.seq&&(this.loading=!1,this.emit())}}setValue(t){this.value=t;let o=this.validate();this.error=o?{message:o,unavailable:!1}:null,this.emit()}validate(){return this.cfg.validate?this.cfg.validate(this.value):null}get valid(){return this.validate()==null}reset(){this.value=this.cfg.value??"",this.error=null,this.emit()}dispose(){for(let t of this.depUnsubs)t();this.depUnsubs=[]}};function P(e){if(!e||typeof e!="object")return null;let r=e;if(r.error!==!0)return null;let t=typeof r.message=="string"&&r.message?r.message:"tool call failed",o=typeof r.hint=="string"&&r.hint?` \\u2014 ${r.hint}`:"";return`${t}${o}`}var s=class extends g{constructor(t){super();a(this,"loading",!1);a(this,"error",null);a(this,"lastResult",null);a(this,"cfg");this.cfg=t}async run(){if(this.loading)return;for(let n of this.cfg.fields??[]){let i=n.validate();if(i!=null){this.error={message:i,unavailable:!1},this.emit();return}}if(this.cfg.confirm&&typeof globalThis.confirm=="function"&&!globalThis.confirm(this.cfg.confirm))return;this.loading=!0,this.error=null,this.emit();let t;try{let n=typeof this.cfg.args=="function"?this.cfg.args():this.cfg.args??{};t=await l(this.cfg.tool,n)}catch(n){this.error=v(n),this.loading=!1,this.emit(),this.cfg.onError?.(this.error);return}let o=P(t)??this.cfg.checkResult?.(t)??null;if(o!=null){this.error={message:o,unavailable:!1},this.loading=!1,this.emit(),this.cfg.onError?.(this.error);return}return this.lastResult=t,this.loading=!1,this.emit(),this.cfg.onSuccess?.(t),t}reset(){this.error=null,this.lastResult=null,this.emit()}},d=class extends g{constructor(t){super();a(this,"data",null);a(this,"loading",!1);a(this,"refreshing",!1);a(this,"error",null);a(this,"done",!1);a(this,"cfg");a(this,"timer",null);a(this,"seq",0);this.cfg=t,(t.autoLoad??!0)&&this.load()}async load(){this.clearTimer();let t=++this.seq;this.data==null?this.loading=!0:this.refreshing=!0,this.error=null,this.emit();try{let n=await this.cfg.load();if(t!==this.seq)return;this.data=n,this.done=this.cfg.until?this.cfg.until(n):!0,this.cfg.pollEvery&&!this.done&&(this.timer=setTimeout(()=>void this.load(),this.cfg.pollEvery))}catch(n){if(t!==this.seq)return;this.error=v(n)}finally{t===this.seq&&(this.loading=!1,this.refreshing=!1,this.emit())}}refresh(){return this.load()}stop(){this.clearTimer()}clearTimer(){this.timer&&(clearTimeout(this.timer),this.timer=null)}},h=class extends g{constructor(t){super();a(this,"items",[]);a(this,"page",0);a(this,"pageSize");a(this,"total",0);a(this,"loading",!1);a(this,"error",null);a(this,"cfg");a(this,"seq",0);this.cfg=t,this.pageSize=t.pageSize??20,(t.autoLoad??!0)&&this.loadPage(0)}async loadPage(t){let o=++this.seq;this.loading=!0,this.error=null,this.emit();try{let n=await this.cfg.load({page:t,pageSize:this.pageSize});if(o!==this.seq)return;this.items=n.items??[],this.total=n.total??this.items.length,this.page=t}catch(n){if(o!==this.seq)return;this.error=v(n)}finally{o===this.seq&&(this.loading=!1,this.emit())}}next(){return this.loadPage(this.page+1)}prev(){return this.loadPage(Math.max(0,this.page-1))}get hasMore(){return(this.page+1)*this.pageSize<this.total}};function M(e,r){let t=r.error?.unavailable?"unavailable":r.loading?"loading":r.error?"error":"ready";e.setAttribute("data-lb-state",t),r.error?e.setAttribute("data-lb-error",r.error.message):e.removeAttribute("data-lb-error")}function D(e,r){let t=()=>r.setValue(e.value);e.addEventListener("change",t);let o=r.subscribe(()=>{M(e,r),e.disabled=r.loading,e.innerHTML="";for(let n of r.options){let i=document.createElement("option");i.value=String(n.value),i.textContent=n.label,e.appendChild(i)}e.value=r.value==null?"":String(r.value)});return()=>{e.removeEventListener("change",t),o()}}function z(e,r){let t=e.type==="checkbox",o=e.tagName==="SELECT"?"change":"input",n=()=>r.setValue(t?e.checked:e.value);e.addEventListener(o,n);let i=r.subscribe(()=>{if(t)e.checked=!!r.value;else{let u=r.value==null?"":String(r.value);e.value!==u&&(e.value=u)}e.setAttribute("data-lb-state",r.error?"error":"ready"),r.error?e.setAttribute("data-lb-error",r.error.message):e.removeAttribute("data-lb-error")});return()=>{e.removeEventListener(o,n),i()}}function F(e,r){let t=n=>{n.preventDefault(),r.run()};e.addEventListener("click",t);let o=r.subscribe(()=>{let n=r.error?.unavailable?"unavailable":r.loading?"loading":r.error?"error":r.lastResult!=null?"success":"idle";e.setAttribute("data-lb-state",n),"disabled"in e&&(e.disabled=r.loading),r.error?e.setAttribute("data-lb-error",r.error.message):e.removeAttribute("data-lb-error")});return()=>{e.removeEventListener("click",t),o()}}var q=["STILL_CHASING","COULD_NOT_REACH_STILL_TRYING","INTEREST_VALIDATED_OR_MEETING_PLANED","NOT_INTERESTED_LOST"],k=[{value:"",label:"Default ranking"},{value:"SCORE:DESC",label:"Score \\u2193"},{value:"SCORE:ASC",label:"Score \\u2191"},{value:"NAME:ASC",label:"Name A\\u2192Z"},{value:"NAME:DESC",label:"Name Z\\u2192A"},{value:"SIZE:DESC",label:"Size \\u2193"},{value:"SIZE:ASC",label:"Size \\u2191"},{value:"SECTOR:ASC",label:"Sector A\\u2192Z"},{value:"STATUS:ASC",label:"Status A\\u2192Z"},{value:"CONTACT_COUNT:DESC",label:"Contacts \\u2193"},{value:"LAST_PROSPECTING_ACTION_AT:DESC",label:"Last action \\u2193"},{value:"LAST_PROSPECTING_ACTION_AT:ASC",label:"Last action \\u2191"},{value:"EPILOGUE_STATUS_SET_AT:DESC",label:"Outcome set \\u2193"},{value:"LIKED:DESC",label:"Liked first"},{value:"DISLIKED:DESC",label:"Disliked first"}];function U(e){let r=String(e??"").trim().toUpperCase(),t=k.some(o=>o.value===r);return new b({kind:"select",value:t?r:"",load:async()=>k.slice()})}var m=[{value:"WANTED",label:"Wanted"},{value:"WON",label:"Won"},{value:"LOST",label:"Lost"},{value:"UNWANTED",label:"Unwanted"}],H={value:"",label:"\\u2014 Not set \\u2014"};function W(e){let r=String(e??"").trim().toUpperCase(),t=m.some(o=>o.value===r);return new b({kind:"select",value:t?r:"",validate:o=>String(o??"")===""?"Pick a status":null,load:async()=>t?m.slice():[H,...m]})}function $(e){let r=()=>{let t=typeof e.leadIds=="function"?e.leadIds():e.leadIds;return Array.isArray(t)?t:e.leadId?[e.leadId]:[]};return new s({tool:"leadbay_set_lead_status",fields:e.date?[e.status,e.date]:[e.status],confirm:e.confirm,args:()=>({lead_ids:r(),status:e.status.value,...e.date&&e.date.value?{status_date:e.date.value}:{},...e.ask?{_triggered_by:e.ask}:{}}),checkResult:t=>{let o=t?.failed;if(!Array.isArray(o)||o.length===0)return null;let n=r().length,i=o[0]?.message??"write rejected";return o.length===n?`Status not applied: ${i}`:`${o.length} of ${n} leads failed: ${i}`}})}function j(e){return new b({kind:"select",load:()=>l("leadbay_list_campaigns",{_triggered_by:e}),options:r=>(r?.campaigns??[]).map(o=>{let n=o?.campaign??o;return n?.id?{value:n.id,label:n.name??n.ai_generated_name??String(n.id)}:null}).filter(o=>o!=null)})}function V(e){return new s({tool:"leadbay_report_outreach",fields:e.note?[e.note]:[],args:()=>({lead_id:e.leadId,...e.status?{epilogue_status:e.status.value}:{},note:e.note?e.note.value:"",verification:{source:"user_confirmed",ref:e.ref??"logged from artifact"},_triggered_by:e.ask})})}function G(e){return new s({tool:"leadbay_add_note",fields:[e.note],args:()=>({leadId:e.leadId,note:e.note.value})})}function Z(e){return new s({tool:"leadbay_like_lead",args:{lead_id:e}})}function Y(e){return new s({tool:"leadbay_dislike_lead",args:{lead_id:e}})}function B(e,r){return new d({autoLoad:!1,load:()=>l("leadbay_account_history",{leadId:e,_triggered_by:r})})}function K(e,r){return new d({autoLoad:!1,load:()=>l("leadbay_research_lead_by_id",{leadId:e,_triggered_by:r})})}function J(e){let r=null;return new d({...e.autoLoad!==void 0?{autoLoad:e.autoLoad}:{},pollEvery:e.pollEvery??4e3,until:t=>!!t?.all_done,load:async()=>{if(!r){let t=await l("leadbay_enrich_titles",{...e.leadIds?{leadIds:e.leadIds}:{},titles:e.titles,...e.email!==void 0?{email:e.email}:{},...e.phone!==void 0?{phone:e.phone}:{},...e.confirm!==void 0?{confirm:e.confirm}:{},_triggered_by:e.ask});if(r=t?.bulk_id??null,!r)return{...t,all_done:!0,no_job:!0}}return l("leadbay_bulk_enrich_status",{bulk_id:r,_triggered_by:e.ask})}})}function Q(e){let r=()=>typeof e.order=="string"?e.order:String(e.order?.value??"");return new h({pageSize:e.pageSize??20,load:async({page:t,pageSize:o})=>{let n=await l("leadbay_pull_leads",{page:t,count:o,...e.lensId?{lensId:e.lensId}:{},...r()?{order:r()}:{},_triggered_by:e.ask}),i=n.leads??[];return{items:i,total:n.pagination?.total??i.length}}})}function X(e){let r=e.source??"followups",t=()=>typeof e.order=="string"?e.order:String(e.order?.value??"");return new h({pageSize:e.pageSize??20,load:async({page:o,pageSize:n})=>{let u=r==="campaign"?await l("leadbay_campaign_call_sheet",{campaign_id:e.campaignId,page:o,count:n,_triggered_by:e.ask}):await l("leadbay_pull_followups",{page:o,count:n,...e.city?{city:e.city}:{},...t()?{order:t()}:{},_triggered_by:e.ask}),w=u.leads??u.items??[];return{items:w,total:u.total_leads??u.pagination?.total??w.length}}})}function ee(e){return new d({load:()=>l("leadbay_team_activity",{weeks:e.weeks??4,_triggered_by:e.ask})})}var re={VERSION:x,configure:O,styles:R,call:l,field:e=>new b(e),action:e=>new s(e),resource:e=>new d(e),list:e=>new h(e),bindSelect:D,bindValue:z,bindAction:F,campaigns:j,outreach:V,note:G,like:Z,dislike:Y,leadStatus:W,setStatus:$,sortOrder:U,leadHistory:B,leadProfile:K,enrichment:J,callList:X,leadList:Q,teamActivity:ee,EPILOGUE_STATUSES:q,LEAD_STATUSES:m,SORT_ORDERS:k};typeof globalThis<"u"&&(globalThis.LeadbayArtifacts=re);})();';
+    ARTIFACT_RUNTIME = '"use strict";(()=>{var L=Object.defineProperty;var A=(e,r,t)=>r in e?L(e,r,{enumerable:!0,configurable:!0,writable:!0,value:t}):e[r]=t;var a=(e,r,t)=>A(e,typeof r!="symbol"?r+"":r,t);var _=`\n:root{\n--color-black:#191919;--color-white:#fff;\n--color-gray-1:#f9f9f9;--color-gray-2:#f0f0f0;--color-gray-3:#e0e0e0;--color-gray-4:#cecece;\n--color-gray-5:#c4c4c4;--color-gray-6:#8d8d8d;--color-gray-7:#787878;--color-gray-8:#646464;\n--color-gray-9:#202020;\n--color-linkedin:#0a66c2;\n--color-blue-background:oklch(0.947 0.029 251);--color-blue-foreground:oklch(0.564 0.181 251);\n--color-green-background:oklch(0.947 0.029 141);--color-green-foreground:oklch(0.564 0.181 141);\n--color-red-background:oklch(0.947 0.029 26);--color-red-foreground:oklch(0.564 0.191 26);\n--color-gold-background:oklch(0.972 0.049 91);--color-gold-foreground:oklch(0.667 0.177 91);\n--color-cherry-background:oklch(0.947 0.029 15);--color-cherry-foreground:oklch(0.44 0.146 15);\n--color-red-like:var(--color-cherry-foreground);\n--lb-font:"Nikkei Maru",system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;\n--lb-radius:1rem;--lb-radius-sm:0.625rem;--lb-gap:0.75rem;\n--lb-surface:var(--color-gray-1);--lb-border:var(--color-gray-3);\n--lb-fg:var(--color-black);--lb-muted:var(--color-gray-8);--lb-field:var(--color-white);\n}\n:root[data-theme=dark],:root[data-lb-theme=dark]{\n--lb-surface:var(--color-gray-9);--lb-border:var(--color-gray-8);\n--lb-fg:var(--color-white);--lb-muted:var(--color-gray-3);--lb-field:var(--color-gray-9);\n}\n@media(prefers-color-scheme:dark){:root:not([data-theme=light]):not([data-lb-theme=light]){\n--lb-surface:var(--color-gray-9);--lb-border:var(--color-gray-8);\n--lb-fg:var(--color-white);--lb-muted:var(--color-gray-3);--lb-field:var(--color-gray-9);\n}}\n.lb-card{display:grid;gap:var(--lb-gap);padding:0.875rem;\nbackground-color:var(--lb-surface);border:1px solid var(--lb-border);\nborder-radius:var(--lb-radius);corner-shape:squircle;color:var(--lb-fg);\nfont-family:var(--lb-font);\nbox-shadow:0 1rem 2.5rem color-mix(in srgb,var(--color-gray-9) 6%,transparent),\n0 0.125rem 0.5rem color-mix(in srgb,var(--color-gray-9) 4%,transparent)}\n.lb-card-head{display:flex;justify-content:space-between;align-items:baseline;gap:var(--lb-gap)}\n.lb-title{font-size:0.875rem;font-weight:600;line-height:1.25rem;color:var(--lb-fg)}\n.lb-sub{font-size:0.8125rem;line-height:1.125rem;color:var(--lb-muted)}\n.lb-row{display:flex;align-items:center;gap:var(--lb-gap);flex-wrap:wrap}\n.lb-stack{display:grid;gap:var(--lb-gap)}\n.lb-select,.lb-input{font:inherit;font-family:var(--lb-font);font-size:0.8125rem;color:var(--lb-fg);\nbackground-color:var(--lb-field);border:1px solid var(--lb-border);\nborder-radius:var(--lb-radius-sm);corner-shape:squircle;padding:0.4rem 0.55rem;min-height:2.125rem}\n.lb-btn{font:inherit;font-family:var(--lb-font);font-size:0.8125rem;font-weight:600;\ncolor:var(--lb-fg);background-color:var(--lb-field);border:1px solid var(--lb-border);\nborder-radius:var(--lb-radius-sm);corner-shape:squircle;padding:0.4rem 0.85rem;min-height:2.125rem;\ncursor:pointer;transition:background-color .15s,border-color .15s,color .15s}\n.lb-btn:hover:not([disabled]){border-color:var(--color-gray-6)}\n.lb-btn:focus-visible,.lb-select:focus-visible,.lb-input:focus-visible{\noutline:2px solid var(--color-blue-foreground);outline-offset:1px}\n.lb-btn[data-lb-state=loading]{opacity:.55;cursor:progress}\n.lb-btn[data-lb-state=success]{background-color:var(--color-green-background);\nborder-color:var(--color-green-foreground);color:var(--color-green-foreground)}\n.lb-btn[data-lb-state=error],.lb-select[data-lb-state=error]{\nbackground-color:var(--color-red-background);border-color:var(--color-red-foreground);\ncolor:var(--color-red-foreground)}\n.lb-btn[data-lb-state=unavailable],.lb-btn[disabled]{opacity:.5;cursor:not-allowed}\n.lb-msg{font-size:0.8125rem;line-height:1.125rem;color:var(--lb-muted)}\n.lb-msg[data-tone=error]{color:var(--color-red-foreground)}\n.lb-msg[data-tone=ok]{color:var(--color-green-foreground)}\n.lb-chip{display:inline-flex;align-items:center;gap:.25rem;white-space:nowrap;\nfont-size:0.75rem;font-weight:600;line-height:1rem;padding:0.125rem 0.5rem;\nborder-radius:var(--lb-radius-sm);corner-shape:squircle;\nbackground-color:var(--color-gray-2);color:var(--lb-muted)}\n.lb-chip[data-status=WANTED]{background-color:var(--color-blue-background);color:var(--color-blue-foreground)}\n.lb-chip[data-status=WON]{background-color:var(--color-green-background);color:var(--color-green-foreground)}\n.lb-chip[data-status=LOST]{background-color:var(--color-red-background);color:var(--color-red-foreground)}\n.lb-chip[data-status=UNWANTED]{background-color:var(--color-gray-2);color:var(--color-gray-7)}\n.lb-chip[data-taste=liked]{background-color:var(--color-cherry-background);color:var(--color-red-like)}\n.lb-chip[data-taste=disliked]{background-color:var(--color-gray-2);color:var(--color-gray-7)}\n.lb-chips{display:flex;align-items:center;gap:.35rem;flex-wrap:wrap}\n.lb-chip[hidden]{display:none}\n.lb-table{width:100%;border-collapse:collapse;font-family:var(--lb-font);color:var(--lb-fg)}\n.lb-table th,.lb-table td{text-align:left;padding:0.5rem 0.4rem;\nborder-bottom:1px solid var(--lb-border);vertical-align:middle;font-size:0.8125rem}\n.lb-table th{font-size:0.75rem;font-weight:600;color:var(--lb-muted);\ntext-transform:uppercase;letter-spacing:.04em}\n.lb-link{color:var(--color-blue-foreground);text-decoration:none}\n.lb-link:hover{text-decoration:underline}\n/* Quiet text link out of the artifact. Button-height so it shares the row\'s\n   baseline; understated so it never competes with the actions beside it. The\n   arrow is a bare diagonal stroke \\u2014 an escape-hatch marker, not an icon that\n   asks to be read. */\n.lb-link-out{display:inline-flex;align-items:center;gap:.3rem;\nfont-size:0.75rem;line-height:1rem;min-height:2.125rem;\ncolor:var(--lb-fg);text-decoration:none;opacity:.65;transition:opacity .15s}\n.lb-link-out:hover{opacity:1;text-decoration:underline}\n.lb-link-out:focus-visible{outline:2px solid var(--color-blue-foreground);outline-offset:1px;\nborder-radius:var(--lb-radius-sm)}\n.lb-link-out svg{width:.85em;height:.85em;flex-shrink:0}\n/* Pushes whatever follows it to the right edge of an .lb-row, so a trailing\n   link sits on the SAME baseline as the row\'s buttons instead of on its own\n   line below them. */\n.lb-spacer{flex:1 1 auto}\n.lb-spinner{display:inline-block;width:.7em;height:.7em;border:2px solid var(--lb-border);\nborder-top-color:var(--color-blue-foreground);border-radius:50%;animation:lb-spin .8s linear infinite}\n@keyframes lb-spin{to{transform:rotate(1turn)}}\n@media(prefers-reduced-motion:reduce){.lb-spinner{animation:none}\n.lb-btn{transition-property:none}}\n`,p="lb-styles";var x="0.5.0",c=class extends Error{constructor(t,o={}){super(t);a(this,"code");a(this,"raw");this.name="LbError",this.code=o.code,this.raw=o.raw}},y=null,f=3e4;function C(){let e=globalThis.cowork;return e&&typeof e.callMcpTool=="function"?(r,t)=>e.callMcpTool(r,t):null}function S(e){if(e&&typeof e=="object"&&"content"in e){let r=e.content;if(Array.isArray(r)&&r[0]&&typeof r[0].text=="string")return r[0].text}return null}function E(e){if(!e||typeof e!="object")return e;let r=e;if(r.isError)throw new c(S(e)??"tool call failed",{raw:e});if("structuredContent"in r&&r.structuredContent!=null)return r.structuredContent;let t=S(e);if(t!=null)try{return JSON.parse(t)}catch{return t}return e}function I(e){return e instanceof Error?e.message:String(e)}function v(e){let r=e instanceof c?e.code:void 0;return{message:I(e),unavailable:r==="unavailable",code:r}}function O(e={}){y=e.call??null,f=e.timeoutMs??3e4}function R(){if(typeof document>"u"||!document.head)return null;let e=document.getElementById(p);if(e)return e;let r=document.createElement("style");return r.id=p,r.textContent=_,document.head.appendChild(r),r}async function T(e,r){if(!f||f<=0)return e;let t,o=new Promise((n,i)=>{t=setTimeout(()=>i(new c(`"${r}" timed out after ${f}ms`,{code:"timeout"})),f)});try{return await Promise.race([e,o])}finally{t&&clearTimeout(t)}}async function l(e,r={}){if(y)return E(await T(Promise.resolve(y(e,r)),e));let t=C();if(!t)throw new c("Leadbay bridge unavailable (window.cowork absent)",{code:"unavailable"});return E(await T(Promise.resolve(t(e,r)),e))}var g=class{constructor(){a(this,"subs",new Set)}subscribe(r){return this.subs.add(r),r(this),()=>this.subs.delete(r)}emit(){for(let r of this.subs)r(this)}};function N(e){return Array.isArray(e)?e.map(r=>r&&typeof r=="object"?r:{value:r,label:String(r)}):[]}var b=class extends g{constructor(t={}){super();a(this,"kind");a(this,"value");a(this,"options",[]);a(this,"loading",!1);a(this,"error",null);a(this,"ready",!1);a(this,"cfg");a(this,"depUnsubs",[]);a(this,"seq",0);this.cfg=t,this.kind=t.kind,this.value=t.value??"";for(let o of t.dependsOn??[]){let n=o.value;this.depUnsubs.push(o.subscribe(()=>{o.value!==n&&(n=o.value,this.cfg.load&&this.load())}))}t.load&&(t.autoLoad??!0)&&this.load()}async load(){if(!this.cfg.load)return;let t=++this.seq;this.loading=!0,this.error=null,this.emit();try{let o=await this.cfg.load();if(t!==this.seq)return;this.options=this.cfg.options?this.cfg.options(o):N(o),this.ready=!0;let n=this.value==null?"":String(this.value);this.options.length&&(n===""||!this.options.some(i=>String(i.value)===n))&&(this.value=this.options[0].value)}catch(o){if(t!==this.seq)return;this.options=[],this.error=v(o)}finally{t===this.seq&&(this.loading=!1,this.emit())}}setValue(t){this.value=t;let o=this.validate();this.error=o?{message:o,unavailable:!1}:null,this.emit()}validate(){return this.cfg.validate?this.cfg.validate(this.value):null}get valid(){return this.validate()==null}reset(){this.value=this.cfg.value??"",this.error=null,this.emit()}dispose(){for(let t of this.depUnsubs)t();this.depUnsubs=[]}};function P(e){if(!e||typeof e!="object")return null;let r=e;if(r.error!==!0)return null;let t=typeof r.message=="string"&&r.message?r.message:"tool call failed",o=typeof r.hint=="string"&&r.hint?` \\u2014 ${r.hint}`:"";return`${t}${o}`}var s=class extends g{constructor(t){super();a(this,"loading",!1);a(this,"error",null);a(this,"lastResult",null);a(this,"cfg");this.cfg=t}async run(){if(this.loading)return;for(let n of this.cfg.fields??[]){let i=n.validate();if(i!=null){this.error={message:i,unavailable:!1},this.emit();return}}if(this.cfg.confirm&&typeof globalThis.confirm=="function"&&!globalThis.confirm(this.cfg.confirm))return;this.loading=!0,this.error=null,this.emit();let t;try{let n=typeof this.cfg.args=="function"?this.cfg.args():this.cfg.args??{};t=await l(this.cfg.tool,n)}catch(n){this.error=v(n),this.loading=!1,this.emit(),this.cfg.onError?.(this.error);return}let o=P(t)??this.cfg.checkResult?.(t)??null;if(o!=null){this.error={message:o,unavailable:!1},this.loading=!1,this.emit(),this.cfg.onError?.(this.error);return}return this.lastResult=t,this.loading=!1,this.emit(),this.cfg.onSuccess?.(t),t}reset(){this.error=null,this.lastResult=null,this.emit()}},u=class extends g{constructor(t){super();a(this,"data",null);a(this,"loading",!1);a(this,"refreshing",!1);a(this,"error",null);a(this,"done",!1);a(this,"cfg");a(this,"timer",null);a(this,"seq",0);this.cfg=t,(t.autoLoad??!0)&&this.load()}async load(){this.clearTimer();let t=++this.seq;this.data==null?this.loading=!0:this.refreshing=!0,this.error=null,this.emit();try{let n=await this.cfg.load();if(t!==this.seq)return;this.data=n,this.done=this.cfg.until?this.cfg.until(n):!0,this.cfg.pollEvery&&!this.done&&(this.timer=setTimeout(()=>void this.load(),this.cfg.pollEvery))}catch(n){if(t!==this.seq)return;this.error=v(n)}finally{t===this.seq&&(this.loading=!1,this.refreshing=!1,this.emit())}}refresh(){return this.load()}stop(){this.clearTimer()}clearTimer(){this.timer&&(clearTimeout(this.timer),this.timer=null)}},h=class extends g{constructor(t){super();a(this,"items",[]);a(this,"page",0);a(this,"pageSize");a(this,"total",0);a(this,"loading",!1);a(this,"error",null);a(this,"cfg");a(this,"seq",0);this.cfg=t,this.pageSize=t.pageSize??20,(t.autoLoad??!0)&&this.loadPage(0)}async loadPage(t){let o=++this.seq;this.loading=!0,this.error=null,this.emit();try{let n=await this.cfg.load({page:t,pageSize:this.pageSize});if(o!==this.seq)return;this.items=n.items??[],this.total=n.total??this.items.length,this.page=t}catch(n){if(o!==this.seq)return;this.error=v(n)}finally{o===this.seq&&(this.loading=!1,this.emit())}}next(){return this.loadPage(this.page+1)}prev(){return this.loadPage(Math.max(0,this.page-1))}get hasMore(){return(this.page+1)*this.pageSize<this.total}};function M(e,r){let t=r.error?.unavailable?"unavailable":r.loading?"loading":r.error?"error":"ready";e.setAttribute("data-lb-state",t),r.error?e.setAttribute("data-lb-error",r.error.message):e.removeAttribute("data-lb-error")}function D(e,r){let t=()=>r.setValue(e.value);e.addEventListener("change",t);let o=r.subscribe(()=>{M(e,r),e.disabled=r.loading,e.innerHTML="";for(let n of r.options){let i=document.createElement("option");i.value=String(n.value),i.textContent=n.label,e.appendChild(i)}e.value=r.value==null?"":String(r.value)});return()=>{e.removeEventListener("change",t),o()}}function z(e,r){let t=e.type==="checkbox",o=e.tagName==="SELECT"?"change":"input",n=()=>r.setValue(t?e.checked:e.value);e.addEventListener(o,n);let i=r.subscribe(()=>{if(t)e.checked=!!r.value;else{let d=r.value==null?"":String(r.value);e.value!==d&&(e.value=d)}e.setAttribute("data-lb-state",r.error?"error":"ready"),r.error?e.setAttribute("data-lb-error",r.error.message):e.removeAttribute("data-lb-error")});return()=>{e.removeEventListener(o,n),i()}}function F(e,r){let t=n=>{n.preventDefault(),r.run()};e.addEventListener("click",t);let o=r.subscribe(()=>{let n=r.error?.unavailable?"unavailable":r.loading?"loading":r.error?"error":r.lastResult!=null?"success":"idle";e.setAttribute("data-lb-state",n),"disabled"in e&&(e.disabled=r.loading),r.error?e.setAttribute("data-lb-error",r.error.message):e.removeAttribute("data-lb-error")});return()=>{e.removeEventListener("click",t),o()}}var q=["STILL_CHASING","COULD_NOT_REACH_STILL_TRYING","INTEREST_VALIDATED_OR_MEETING_PLANED","NOT_INTERESTED_LOST"],k=[{value:"",label:"Default ranking"},{value:"SCORE:DESC",label:"Score \\u2193"},{value:"SCORE:ASC",label:"Score \\u2191"},{value:"NAME:ASC",label:"Name A\\u2192Z"},{value:"NAME:DESC",label:"Name Z\\u2192A"},{value:"SIZE:DESC",label:"Size \\u2193"},{value:"SIZE:ASC",label:"Size \\u2191"},{value:"SECTOR:ASC",label:"Sector A\\u2192Z"},{value:"STATUS:ASC",label:"Status A\\u2192Z"},{value:"CONTACT_COUNT:DESC",label:"Contacts \\u2193"},{value:"LAST_PROSPECTING_ACTION_AT:DESC",label:"Last action \\u2193"},{value:"LAST_PROSPECTING_ACTION_AT:ASC",label:"Last action \\u2191"},{value:"EPILOGUE_STATUS_SET_AT:DESC",label:"Outcome set \\u2193"},{value:"LIKED:DESC",label:"Liked first"},{value:"DISLIKED:DESC",label:"Disliked first"}];function U(e){let r=String(e??"").trim().toUpperCase(),t=k.some(o=>o.value===r);return new b({kind:"select",value:t?r:"",load:async()=>k.slice()})}var m=[{value:"WANTED",label:"Wanted"},{value:"WON",label:"Won"},{value:"LOST",label:"Lost"},{value:"UNWANTED",label:"Unwanted"}],H={value:"",label:"\\u2014 Not set \\u2014"};function j(e){let r=String(e??"").trim().toUpperCase(),t=m.some(o=>o.value===r);return new b({kind:"select",value:t?r:"",validate:o=>String(o??"")===""?"Pick a status":null,load:async()=>t?m.slice():[H,...m]})}function W(e){let r=()=>{let t=typeof e.leadIds=="function"?e.leadIds():e.leadIds;return Array.isArray(t)?t:e.leadId?[e.leadId]:[]};return new s({tool:"leadbay_set_lead_status",fields:e.date?[e.status,e.date]:[e.status],confirm:e.confirm,args:()=>({lead_ids:r(),status:e.status.value,...e.date&&e.date.value?{status_date:e.date.value}:{},...e.ask?{_triggered_by:e.ask}:{}}),checkResult:t=>{let o=t?.failed;if(!Array.isArray(o)||o.length===0)return null;let n=r().length,i=o[0]?.message??"write rejected";return o.length===n?`Status not applied: ${i}`:`${o.length} of ${n} leads failed: ${i}`}})}function $(e){return new b({kind:"select",load:()=>l("leadbay_list_campaigns",{_triggered_by:e}),options:r=>(r?.campaigns??[]).map(o=>{let n=o?.campaign??o;return n?.id?{value:n.id,label:n.name??n.ai_generated_name??String(n.id)}:null}).filter(o=>o!=null)})}function V(e){return new s({tool:"leadbay_report_outreach",fields:e.note?[e.note]:[],args:()=>({lead_id:e.leadId,...e.status?{epilogue_status:e.status.value}:{},note:e.note?e.note.value:"",verification:{source:"user_confirmed",ref:e.ref??"logged from artifact"},_triggered_by:e.ask})})}function G(e){return new s({tool:"leadbay_add_note",fields:[e.note],args:()=>({leadId:e.leadId,note:e.note.value})})}function Z(e){return new s({tool:"leadbay_like_lead",args:{lead_id:e}})}function Y(e){return new s({tool:"leadbay_dislike_lead",args:{lead_id:e}})}function B(e,r){return new u({autoLoad:!1,load:()=>l("leadbay_account_history",{leadId:e,_triggered_by:r})})}function K(e,r){return new u({autoLoad:!1,load:()=>l("leadbay_research_lead_by_id",{leadId:e,_triggered_by:r})})}function J(e){let r=null;return new u({...e.autoLoad!==void 0?{autoLoad:e.autoLoad}:{},pollEvery:e.pollEvery??4e3,until:t=>!!t?.all_done,load:async()=>{if(!r){let t=await l("leadbay_enrich_titles",{...e.leadIds?{leadIds:e.leadIds}:{},titles:e.titles,...e.email!==void 0?{email:e.email}:{},...e.phone!==void 0?{phone:e.phone}:{},...e.confirm!==void 0?{confirm:e.confirm}:{},_triggered_by:e.ask}),o=Array.isArray(t?.lead_ids)?t.lead_ids:[],n=t?.notification_id??null;if(r=n||o.length>0?{notification_id:n,lead_ids:o}:null,!r)return{...t,all_done:!0,no_job:!0}}return l("leadbay_bulk_enrich_status",{...r.notification_id?{notification_id:r.notification_id}:{},...r.lead_ids.length>0?{lead_ids:r.lead_ids}:{},...e.titles?{titles:e.titles}:{},...e.email!==void 0?{email:e.email}:{},...e.phone!==void 0?{phone:e.phone}:{},_triggered_by:e.ask})}})}function Q(e){let r=()=>typeof e.order=="string"?e.order:String(e.order?.value??"");return new h({pageSize:e.pageSize??20,load:async({page:t,pageSize:o})=>{let n=await l("leadbay_pull_leads",{page:t,count:o,...e.lensId?{lensId:e.lensId}:{},...r()?{order:r()}:{},_triggered_by:e.ask}),i=n.leads??[];return{items:i,total:n.pagination?.total??i.length}}})}function X(e){let r=e.source??"followups",t=()=>typeof e.order=="string"?e.order:String(e.order?.value??"");return new h({pageSize:e.pageSize??20,load:async({page:o,pageSize:n})=>{let d=r==="campaign"?await l("leadbay_campaign_call_sheet",{campaign_id:e.campaignId,page:o,count:n,_triggered_by:e.ask}):await l("leadbay_pull_followups",{page:o,count:n,...e.city?{city:e.city}:{},...t()?{order:t()}:{},_triggered_by:e.ask}),w=d.leads??d.items??[];return{items:w,total:d.total_leads??d.pagination?.total??w.length}}})}function ee(e){return new u({load:()=>l("leadbay_team_activity",{weeks:e.weeks??4,_triggered_by:e.ask})})}var re={VERSION:x,configure:O,styles:R,call:l,field:e=>new b(e),action:e=>new s(e),resource:e=>new u(e),list:e=>new h(e),bindSelect:D,bindValue:z,bindAction:F,campaigns:$,outreach:V,note:G,like:Z,dislike:Y,leadStatus:j,setStatus:W,sortOrder:U,leadHistory:B,leadProfile:K,enrichment:J,callList:X,leadList:Q,teamActivity:ee,EPILOGUE_STATUSES:q,LEAD_STATUSES:m,SORT_ORDERS:k};typeof globalThis<"u"&&(globalThis.LeadbayArtifacts=re);})();';
     ARTIFACT_USAGE_GUIDE = '# Leadbay Artifact Kit \u2014 headless domain components\n\nYou are building a single-file HTML **artifact** the user runs inside cowork. This\nkit gives you **headless view-models** that own a control\'s whole data lifecycle \u2014\nload/populate from a Leadbay call, hold value/state, poll, validate, and\nencapsulate the API call + business rules. **You own 100% of markup/layout/style.**\nThe library renders nothing. Inline the runtime once as a `<script>`; it exposes\none global `window.LeadbayArtifacts` (call it `lb`). Vanilla, no React, no build.\n\nPass every tool you use as the artifact\'s `mcp_tools` so the host permits it.\n\n## Two layers\n\n**Primitives** (generic):\n- `lb.field({ load, options, value, validate, dependsOn })` \u2014 a value + optionally\n  API-populated options. `.value/.setValue/.options/.loading/.error/.valid/.subscribe`.\n- `lb.action({ tool, args, fields, confirm, onSuccess, onError })` \u2014 a write/submit.\n  `.run()/.loading/.error/.lastResult/.subscribe`.\n- `lb.resource({ load, pollEvery?, until?, autoLoad? })` \u2014 one read that may change:\n  load-on-click or poll-until-`until`. `.data/.loading/.refreshing/.error/.done/.load()/.refresh()/.stop()/.subscribe`.\n- `lb.list({ load, pageSize })` \u2014 paginated rows. `.items/.page/.total/.loading/.loadPage(n)/.next()/.prev()/.hasMore/.subscribe`.\n\n`.error` is `{ message, unavailable } | null`. `subscribe(cb)` fires immediately\nthen on every change \u2014 render your own DOM from it.\n\n**Domain components** (pre-wired \u2014 bake in the tool name, arg shape, and footguns):\n\n| Call | Returns | For |\n|---|---|---|\n| `lb.campaigns(ask)` | field | a campaign `<select>`, options from `leadbay_list_campaigns` |\n| `lb.outreach({leadId, ask, status?, note?})` | action | log a call \u2192 `report_outreach` (verification + `_triggered_by` baked in) |\n| `lb.note({leadId, note})` | action | add a note \u2192 `add_note` |\n| `lb.like(leadId)` / `lb.dislike(leadId)` | action | taste signal |\n| `lb.leadStatus(current?)` | field | a status `<select>` (Wanted/Won/Lost/Unwanted) |\n| `lb.setStatus({leadId or leadIds, status, date?, ask})` | action | write the org CRM status \u2192 `set_lead_status` |\n| `lb.leadHistory(leadId, ask)` | resource (lazy) | notes + activities + engagement \u2192 `account_history` |\n| `lb.leadProfile(leadId, ask)` | resource (lazy) | full lead profile \u2192 `research_lead_by_id` |\n| `lb.sortOrder(current?)` | field | a sort `<select>` mirroring the app\'s TableSort |\n| `lb.leadList({lensId?, order?, ask})` | list | a sortable Discover batch \u2192 `pull_leads` |\n| `lb.callList({source:\'followups\'\\|\'campaign\', campaignId?, city?, ask})` | list | a cold-call list (Monitor or a campaign) |\n| `lb.enrichment({leadIds, titles, ask, pollEvery?})` | resource (polling) | launch + watch contact enrichment |\n| `lb.teamActivity({weeks, ask})` | resource | manager leaderboard + activity trend \u2192 `leadbay_team_activity` |\n\n`lb.EPILOGUE_STATUSES` = the 4 disposition values\n(`STILL_CHASING`, `COULD_NOT_REACH_STILL_TRYING`, `INTEREST_VALIDATED_OR_MEETING_PLANED`, `NOT_INTERESTED_LOST`).\n`lb.LEAD_STATUSES` = the 4 org CRM statuses as `{value,label}` (`WANTED`, `WON`, `LOST`, `UNWANTED`).\n`lb.SORT_ORDERS` = the sort options as `{value,label}`; values are the backend `FIELD:ASC|DESC` enum.\n\n**Sorting is a SERVER concern.** `lb.leadList` and `lb.callList` take an `order`\n(a `lb.sortOrder()` field or a literal) and send it upstream; the backend sorts\nthe whole lens / Monitor and returns the requested page of that. Never re-sort\nrows in the browser \u2014 you would be reordering one page of a larger set, showing\nleads that do not belong at that position. The empty value means "no order\nparam", i.e. the tab\'s own ranking, which is the right default. Changing the\nsort should reset to page 0. Campaign call sheets cannot sort:\n`leadbay_campaign_call_sheet` has no `order` param, and `lb.callList` drops it\nfor that source rather than sending something the tool would reject.\n\n**Two different systems.** Epilogue = how one outreach attempt went (drives\nfollow-up ranking). Lead status = the commercial outcome, org-wide \u2014 the same\nfield the website\'s status selector writes. A won deal is a LEAD STATUS;\n"she didn\'t pick up" is an EPILOGUE. Setting one never sets the other, so when\nthe user reports both in one breath, fire both actions.\n\n**Binding sugar** (optional; binds a view-model to YOUR native element, no style):\n`lb.bindSelect(selectEl, field)` (populates options + value), `lb.bindValue(inputEl, field)`,\n`lb.bindAction(buttonEl, action)`. They set `data-lb-state`\n(`ready|loading|error|success|unavailable`) + `data-lb-error` on your element as\nstyling hooks. For lists/resources, use `.subscribe()` and render yourself.\n\n`ask` is the user\'s request this artifact serves \u2014 it becomes `_triggered_by`.\n\n## The skin (optional) \u2014 `lb.styles()`\n\nCall it once and you get a small `lb-*` stylesheet, so every artifact you build\nshares one visual language instead of re-inventing padding and colours. It is\n**opt-in**: skip it and you get exactly the unstyled HTML you wrote. It injects\nno markup and never touches your `class` attributes.\n\n```js\nlb.styles();   // idempotent \u2014 safe to call per row\n```\n\n| Class | For |\n|---|---|\n| `lb-card` / `lb-card-head` / `lb-title` / `lb-sub` | a lead card + its header |\n| `lb-row` / `lb-stack` / `lb-spacer` | control row / vertical spacing / flex filler that right-aligns what follows |\n| `lb-link-out` | quiet external link (icon inherits currentColor) \u2014 "Open in Leadbay" |\n| `lb-select` / `lb-input` / `lb-btn` | form controls (state-aware, see below) |\n| `lb-msg` (`data-tone="error\\|ok"`) | inline feedback |\n| `lb-chip` (`data-status="WON\\|LOST"`) | a status pill |\n| `lb-table` | leads table |\n| `lb-spinner` | inline busy indicator |\n\nControls react to the `data-lb-state` the bind helpers already set \u2014 a bound\n`lb-btn` dims while loading, goes green on success, red on error, all with no\nextra CSS from you.\n\nThe palette is the **product design system**, ported from\n`frontend/packages/style/color.css` \u2014 same `--color-gray-1\u20269` ramp, same\nsemantic `--color-{green,red,blue,gold}-{background,foreground}` pairs, same\n`1rem` / `0.625rem` radii and `corner-shape: squircle` as the app\'s components.\nAn artifact therefore looks like Leadbay, not like a generic page.\n\nUse the tokens rather than hardcoded colours \u2014 the same rule the style package\nenforces. Re-theme by overriding them; don\'t fight specificity:\n\n```css\n:root { --lb-surface: var(--color-gray-2); --lb-radius: 0.5rem; }\n```\n\nDark mode works two ways: `data-theme="dark"` on `<html>` (the frontend\'s own\nhook) **and** `prefers-color-scheme`, because an artifact renders inside a host\nwhose theme attribute it cannot set. Never hardcode a light background over the\nskin.\n\nThe product face is `Nikkei Maru`; the stack names it first and falls back to\nthe system UI font. Do **not** add an `@font-face` \u2014 artifacts are inline-only\nand a remote font URL will silently fail.\n\n## What every lead card MUST carry\n\nA card is the artifact form of the `pull_leads` table, and it inherits that\ntable\'s rules. A card with a name and a button is not enough: the rep cannot\ntell *why* this lead is on screen. Four lines, in this order.\n\n```html\n<div class="lb-card">\n  <div class="lb-card-head">\n    <span class="lb-title"></span>              <!-- 1. company -->\n    <span class="lb-chips">                     <!-- 2. state -->\n      <span class="lb-chip" data-taste hidden></span>\n      <span class="lb-chip" data-status hidden></span>\n    </span>\n  </div>\n  <div class="lb-sub"></div>                    <!-- 3. firmographics -->\n  <div class="lb-sub" data-why></div>           <!-- 4. why it fits -->\n  <div class="lb-row"><!-- actions --></div>\n</div>\n```\n\n1. **Company** \u2014 `name`, linked to `website` (prefix `https://` on a bare host).\n   Never render the numeric `score`; use the `\u25B0\u2756\u25B1` bar if you want the signal.\n\n   Also give every card an **Open in Leadbay** link to the lead\'s panel in the\n   product. Put it at the **right-hand end of the card\'s last action row** \u2014\n   same row as the buttons, pushed right by an `lb-spacer`, not on a line of\n   its own. Style it `lb-link-out`: quiet text plus a plain arrow-up-right,\n   never a filled button. It is an escape hatch, not a call to action.\n\n   ```html\n   <div class="lb-row">\n     <button class="lb-btn">Like</button>\n     <button class="lb-btn">Set status</button>\n     <span class="lb-spacer"></span>          <!-- pushes the link right -->\n     <a class="lb-link-out" data-k="open" target="_blank" rel="noopener">\n       Open in Leadbay\n       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"\n            stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">\n         <line x1="7" y1="17" x2="17" y2="7"/><polyline points="7 7 17 7 17 17"/>\n       </svg>\n     </a>\n   </div>\n   ```\n\n   Keep the arrow a bare diagonal stroke \u2014 the text already says where the link\n   goes, so the glyph only has to mark "leaves this page". Mark the `<svg>`\n   `aria-hidden="true"`: it is decorative, and the link text is the accessible\n   name.\n   **Pick the view the lead actually lives in** \u2014 the URL is\n   `/app/<view>?lead=<uuid>`, and the three views are `discover`, `monitor`,\n   `campaign`. Landing a Monitor lead on Discover drops the rep into a list\n   that does not contain it:\n\n   ```js\n   function leadUrl(lead, campaignId) {\n     const id = encodeURIComponent(lead.id);\n     // A campaign card carries TWO params \u2014 the campaign selects the list, the\n     // lead opens the panel inside it. Campaign wins even when in_monitor is\n     // also true, because that is the list the rep is looking at.\n     if (campaignId) {\n       return `https://leadbay.app/app/campaign?campaign=${encodeURIComponent(campaignId)}&lead=${id}`;\n     }\n     const view = lead.in_monitor ? "monitor" : "discover";\n     return `https://leadbay.app/app/${view}?lead=${id}`;\n   }\n   openEl.href = leadUrl(lead, campaignId);\n   ```\n\n   `in_monitor` / `in_discover` are booleans on the `pull_followups` payload \u2014\n   every follow-up carries `in_monitor: true`, so a call sheet must link to\n   `monitor`. `pull_leads` omits both flags entirely; its leads are the Discover\n   batch by definition, so `discover` is the default. A campaign card\n   (`lb.callList({source:"campaign", campaignId})`) needs `?campaign=<id>&lead=<id>`\n   \u2014 the param names are `CAMPAIGN_QUERY_PARAM` and `LEAD_QUERY_PARAM`, and the\n   app\'s own `useLeadPanel` preserves whatever params are already set, so the\n   two coexist by design. Omitting `campaign=` opens an empty campaign view.\n\n   Inline the glyph as SVG rather than an emoji or `\u2197` \u2014 it inherits\n   `currentColor` and scales with the text, so it stays legible in both themes.\n   `?lead=<uuid>` is the real deep-link (`LEAD_QUERY_PARAM` in the web app, read\n   on load; the panel is an overlay, so the view choice only decides what sits\n   behind it). This is the ONE place a card may use `lead.id`: as a link target,\n   never as visible text.\n2. **State chips** \u2014 taste (`data-taste`) and CRM status (`data-status`) are\n   INDEPENDENT axes; render both, hide the empty one. Never collapse to one chip.\n3. **Firmographics** \u2014 sector of activity first, then city, then size, then the\n   contact. `sector_id` is a RAW ID (`"5136"`), not a label: resolve it via\n   `leadbay_list_sectors` (1346 rows \u2014 fetch once, cache, never inline the lot)\n   or omit it. Never print the raw id.\n\n   **Always show whether the lead is reachable \u2014 and never merge the person\n   with the company\'s switchboard.** These are two separate lines:\n\n   ```js\n   // WHO \u2014 recommended_contact. Name, and job_title ONLY when present; on list\n   // payloads it is usually null, and inventing one is worse than omitting it.\n   const rc = lead.recommended_contact;\n   const who = rc ? [rc.first_name, rc.last_name].filter(Boolean).join(" ") : null;\n   const whoLine = who ? who + (rc.job_title ? " \xB7 " + rc.job_title : "") : "No named contact";\n\n   // HOW \u2014 company-level channels. `phone_numbers` and `email` belong to the\n   // COMPANY, not to `recommended_contact`. Rendering "Jean \xB7 \u260E 0123\u2026" claims a\n   // direct line that does not exist; it is the switchboard.\n   const phone = (lead.phone_numbers || [])[0] || null;\n   // The API returns the STRING "null" for a missing email \u2014 guard for it or\n   // you will print the word "null" as an address.\n   const email = lead.email && lead.email !== "null" ? lead.email : null;\n   const howLine = [phone && "\u260E " + phone, email && "\u2709 " + email].filter(Boolean)\n     .join(" \xB7 ") || "No direct channel \u2014 enrich to reveal";\n   ```\n\n   ```html\n   <div class="lb-sub">Sector \xB7 City \xB7 Size</div>\n   <div class="lb-sub">\u{1F464} Jean-Fran\xE7ois Froemer \xB7 G\xE9rant</div>   <!-- WHO -->\n   <div class="lb-sub">\u{1F3E2} \u260E 01 23 45 67 89</div>                 <!-- HOW: company -->\n   ```\n\n   Label the channel line as the **company\'s**, so a rep reading fast cannot\n   mistake it for a direct line. A per-contact email or phone exists only after\n   enrichment \u2014 `research_lead_by_id` exposes it as `contacts.reachable[]`, and\n   `_meta.has_reachable_contact` is the authoritative flag. The list payloads\n   carry neither, so a card built from `pull_leads` / `pull_followups` can only\n   ever show company channels. Say "enrich to reveal" rather than implying the\n   contact is callable.\n\n   Two things that look like reachability and are not: a `linkedin_page` alone\n   (the rep cannot message a URL without leaving the artifact \u2014 same rule\n   `research_lead_by_id` applies), and `contacts_count > 0` (it counts known\n   people, not people you can contact; a lead can show 2518 contacts and zero\n   channels). `pull_followups` carries `has_phone` as a ready-made boolean;\n   `pull_leads` omits it, so derive from `phone_numbers` there.\n4. **Why it fits** \u2014 one sentence, \u226420 words. Walk this chain and stop at the\n   first hit:\n\n   1. `short_description`\n   2. `description` (longer; only on `research_lead_by_id` /\n      `research_lead_by_name_fuzzy` \u2014 the trim payloads omit it)\n   3. top 2 `tags[].display_name`\n   4. `qualification_summary.best_response_excerpt`, trimmed to one sentence\n   5. `keywords`, first 3, joined with ` \xB7 `\n   6. the resolved sector label \u2014 better than nothing, and if step 3 already\n      printed the sector on the firmographics line, skip to step 7\n   7. the literal *"No description yet \u2014 run qualification to generate one"*\n\n   Never leave this line blank: a silent gap reads as a rendering bug, whereas\n   the fallback tells the rep the data is missing and what fixes it.\n\n   **The two list payloads are complementary, so the chain must span both.**\n   `pull_leads` returns `short_description` on every lead but no `sector_id`;\n   `pull_followups` returns `sector_id` but no `short_description` at all. A\n   card fed by one will fall through to a different step than the same card fed\n   by the other \u2014 that is expected, not a bug. Never call\n   `research_lead_by_id` per row just to fill this line: it is one request per\n   lead. Fetch it lazily when the rep expands a card.\n\n**Never show** on a card: `id`, `sector_id`, `location.pos`, `location.country`\n(unless city and state are both missing), `is_hq`, `*_in_progress`,\n`highlighted_fields`, `custom_fields`, `stale_at`, `deal_insights`,\n`need_attention*`, any count that is 0, any value that is the string `"null"`.\n\n**Minimum actions.** A card that only displays is a table row that costs more \u2014\nif you are not wiring an action, render the markdown table instead. Wire at\nleast one write, and prefer the set the rep actually needs:\n\n| Card is for | Wire |\n|---|---|\n| triage a discovery batch | `lb.like` / `lb.dislike` + `lb.setStatus` |\n| working a call list | `lb.outreach` (gated on a note) + `lb.leadHistory` |\n| pipeline review | `lb.setStatus` + `lb.note` |\n\nAlways render the `.error` branch of every view-model \u2014 a control that cannot\nreach the host must say so, not sit silent.\n\n## Recipe: cold-call sheet (one row per lead)\n\n```js\nconst lb = window.LeadbayArtifacts; lb.configure();\nconst ASK = "<the user\'s request>";\n\nconst list = lb.callList({ source: "campaign", campaignId: CID, ask: ASK });\nlist.subscribe((l) => renderRows(l.items, l.loading));   // your render\n\n// per lead row (call when you build a row):\nfunction wireRow(lead, els) {\n  const status = lb.field({ value: "STILL_CHASING" });   // static-enum <select>\n  const note   = lb.field({ validate: (v) => (v && v.trim() ? null : "Add a note") });\n  lb.bindValue(els.status, status);\n  lb.bindValue(els.note, note);\n  lb.bindAction(els.log,  lb.outreach({ leadId: lead.id, ask: ASK, status, note }));\n  lb.bindAction(els.like, lb.like(lead.id));\n\n  const history = lb.leadHistory(lead.id, ASK);          // lazy\n  history.subscribe((h) => renderHistory(els.history, h));\n  els.expand.onclick = () => history.load();             // load on click\n}\n```\n\n## Recipe: lead-status dropdown (Wanted / Won / Lost)\n\nThe org-wide CRM status, as a `<select>` + Apply button. You write the markup;\n`lb.leadStatus` fills the options and holds the value, `lb.setStatus` does the write.\n\n```html\n<div class="lb-card">\n  <div class="lb-card-head">\n    <span class="lb-title">Acme Corp</span>\n    <span class="lb-chips">\n      <span id="taste" class="lb-chip" data-taste="liked">Liked</span>\n      <span id="crm"   class="lb-chip" data-status="WANTED">Wanted</span>\n    </span>\n  </div>\n  <div class="lb-row">\n    <select id="st" class="lb-select"></select>\n    <button id="go" class="lb-btn">Apply</button>\n    <span id="msg" class="lb-msg"></span>\n  </div>\n</div>\n```\n\n**Two badges, never one.** Taste (`liked`/`disliked`, from `lb.like`/`lb.dislike`)\nand CRM status (`WANTED`/`WON`/`LOST`/`UNWANTED`, from `lb.setStatus`) are\nindependent axes \u2014 a lead can be liked *and* lost. Collapsing them into a single\nchip destroys information: the rep can no longer see that a lead they liked went\nnowhere. Render `data-taste` and `data-status` as separate chips inside\n`lb-chips`, and hide the one that has no value rather than reusing it.\n\n```js\nlb.styles();                                          // once per artifact \u2014 see below\n\nconst status = lb.leadStatus(lead.org_lead_status);   // seed with the CURRENT value\nconst save   = lb.setStatus({ leadId: lead.id, status, ask: ASK });\n\nlb.bindSelect(document.getElementById("st"), status); // populates the 4 options\nlb.bindAction(document.getElementById("go"), save);   // click \u2192 write\n\nsave.subscribe((a) => {                               // render your own feedback\n  msg.textContent = a.loading ? "Saving\u2026"\n    : a.error ? a.error.message                       // includes partial failures\n    : a.lastResult ? `Set to ${a.lastResult.status}` : "";\n  msg.dataset.tone = a.error ? "error" : a.lastResult ? "ok" : "";\n});\n```\n\nLoading / success / error styling comes free: `bindAction` and `bindSelect` set\n`data-lb-state` (`ready|loading|error|success|unavailable`) and the skin already\ntargets those attributes. No extra wiring.\n\nSave-on-change instead of an Apply button \u2014 drop `bindAction` and run it yourself:\n\n```js\ndocument.getElementById("st").addEventListener("change", () => save.run());\n```\n\n**Bulk apply** across checked rows \u2014 pass `leadIds` and a `confirm`, since one\nclick rewrites a field every rep in the org sees:\n\n```js\nconst bulk = lb.setStatus({\n  leadIds: () => checkedIds,        // \u2190 read at run() time, not at build time\n  status, ask: ASK,\n  confirm: "Set this status on every selected lead?",\n});\n```\n\n`leadIds` is read when the action runs, so a live selection works \u2014 but pass the\narray itself if your selection is fixed. A partial write (some leads rejected)\nsurfaces as `.error`, never as a green button: `setStatus` checks the `failed[]`\nthe tool returns.\n\nThe backend stamps the status date as "now" on every write, which is what a rep\nclicking a dropdown means. Don\'t add a date picker unless the user asks to\nbackdate \u2014 then pass an optional `date` field holding `YYYY-MM-DD`:\n`lb.setStatus({ leadId, status, date, ask })`.\n\n## Recipe: manager dashboard\n\n```js\nconst team = lb.teamActivity({ weeks: 4, ask: ASK });\nteam.subscribe((t) => {\n  if (t.loading) showSpinner();\n  if (t.data) {\n    renderLeaderboard(t.data.reps);   // sorted by total_activities; cols: name, notes, meetings_or_interest, lost\u2026\n    renderTrendChart(t.data.trend);   // [{date,count}] \u2192 Chart.js (allowed from CDN)\n  }\n});\nrefreshBtn.onclick = () => team.refresh();\n```\n\n## Recipe: live enrichment\n\n```js\nconst job = lb.enrichment({ leadIds: [LEAD], titles: ["CEO", "VP Sales"], ask: ASK });\njob.subscribe((j) => {\n  const p = j.data && j.data.overall_progress;            // {done,total,done_ratio}\n  renderBar(p);\n  if (j.done) renderContacts(j.data.leads);               // enriched contacts\n});\nrefreshBtn.onclick = () => job.refresh();\n```\n\n## Write-call rules\n\nThe domain factories handle these for you. If you hand-roll an action:\n`leadbay_report_outreach` args MUST include `verification:{source:"user_confirmed", ref}`\nAND `_triggered_by`; `leadbay_add_leads_to_campaign` needs `_triggered_by`;\n`add_note`/`like_lead`/`dislike_lead` take only their own args. `epilogue_status` is\none of `lb.EPILOGUE_STATUSES`. Snoozing (pushback) is advanced-gated \u2014 not\ncallable from a default artifact. Org lead status IS on the default surface:\nuse `lb.setStatus`, which owns the arg shape AND the partial-write check \u2014\n`leadbay_set_lead_status` writes each lead separately, so it can resolve 200\nwith a non-empty `failed[]`. Hand-rolling that action will report a green\nbutton over a write that never landed.\n\n## Degradation + live updates\n\nIf the host bridge is absent, a view-model\'s `.error` is set with `.error.unavailable\n=== true` (bind helpers set `data-lb-state="unavailable"`) \u2014 nothing throws. Every\ncall also has a **30s timeout** (configurable via `lb.configure({ timeoutMs })`): a\nhost call that never settles becomes `.error` with `code:"timeout"`, so a control is\nnever stuck loading forever \u2014 always render the `.error` branch so the user can retry.\nAuto-poll (`pollEvery`) depends on the cowork host serving FRESH reads; `.refresh()`\nis the guaranteed manual path \u2014 always wire a Refresh control for polling resources.';
   }
 });
@@ -22042,13 +21535,12 @@ __export(dist_exports, {
   COMPOSITE_FILE_TOOL_NAMES: () => COMPOSITE_FILE_TOOL_NAMES,
   DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
   GETTING_STARTED_MANIFEST: () => GETTING_STARTED_MANIFEST,
-  InMemoryBulkStore: () => InMemoryBulkStore,
   LeadbayClient: () => LeadbayClient,
-  LocalBulkStore: () => LocalBulkStore,
   NO_COMMERCE_TOOL_DESCRIPTIONS: () => NO_COMMERCE_TOOL_DESCRIPTIONS,
   NotificationsInbox: () => NotificationsInbox,
   NotificationsWsClient: () => NotificationsWsClient,
   REGIONS: () => REGIONS,
+  abandonLaunch: () => abandonLaunch,
   accountHistory: () => accountHistory,
   accountStatus: () => accountStatus,
   acknowledgeNotification: () => acknowledgeNotification,
@@ -22058,6 +21550,7 @@ __export(dist_exports, {
   anchorIdFor: () => anchorIdFor,
   answerClarification: () => answerClarification,
   artifactKit: () => artifactKit,
+  beginLaunch: () => beginLaunch,
   bulkEnrichStatus: () => bulkEnrichStatus,
   bulkQualifyLeads: () => bulkQualifyLeads,
   campaignCallSheet: () => campaignCallSheet,
@@ -22072,7 +21565,6 @@ __export(dist_exports, {
   createCampaign: () => createCampaign,
   createClient: () => createClient,
   createCustomField: () => createCustomField,
-  createDefaultBulkStore: () => createDefaultBulkStore,
   createLens: () => createLens,
   createLensDraft: () => createLensDraft,
   createTopupLink: () => createTopupLink,
@@ -22112,8 +21604,8 @@ __export(dist_exports, {
   importLeads: () => importLeads,
   importStatus: () => importStatus,
   inferKind: () => inferKind,
-  isValidBulkId: () => isValidBulkId,
   launchBulkEnrichment: () => launchBulkEnrichment,
+  launchFingerprint: () => launchFingerprint,
   likeLead: () => likeLead,
   listCampaigns: () => listCampaigns,
   listLenses: () => listLenses,
@@ -22130,8 +21622,10 @@ __export(dist_exports, {
   pullLeads: () => pullLeads,
   qualifyLead: () => qualifyLead,
   qualifyStatus: () => qualifyStatus,
+  recallLaunch: () => recallLaunch,
   recallOrderedTitles: () => recallOrderedTitles,
   refinePrompt: () => refinePrompt,
+  rememberLaunch: () => rememberLaunch,
   removeEpilogue: () => removeEpilogue,
   removeLeadsFromCampaign: () => removeLeadsFromCampaign,
   removePushback: () => removePushback,
@@ -22139,6 +21633,7 @@ __export(dist_exports, {
   reportOutreach: () => reportOutreach,
   researchLeadById: () => researchLeadById,
   researchLeadByNameFuzzy: () => researchLeadByNameFuzzy,
+  resetLaunchGuard: () => resetLaunchGuard,
   resolveImportRows: () => resolveImportRows,
   resolveRegion: () => resolveRegion,
   reviseHintFor: () => reviseHintFor,
@@ -22269,9 +21764,9 @@ var init_dist = __esm({
     init_team_activity();
     init_send_feedback();
     init_artifact_kit();
-    init_bulk_store();
     init_getting_started();
     init_tool_descriptions_generated();
+    init_launch_guard();
     granularReadTools = [
       listLenses,
       discoverLeads,
@@ -22549,7 +22044,7 @@ If the prompt's body and the tool's RENDERING appear to conflict, the tool's REN
 
 # Resilience rules for Leadbay long-running tools
 
-These four rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
+These rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
 
 ## Rule 1 \u2014 Pin the lens
 
@@ -22557,7 +22052,7 @@ After your first \`leadbay_pull_leads\` call, capture \`response.lens.id\` into
 
 ## Rule 2 \u2014 Prefer async for bulk operations
 
-\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\`, which returns \`{status:'running', qualify_id}\` immediately. Then poll \`leadbay_qualify_status\` (or \`leadbay_import_status\`) every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
+\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\` and return immediately. They hand back different ids: \`bulk_qualify_leads\` returns \`{status:'running', notification_id, lead_ids, lens_id}\` \u2014 poll \`leadbay_qualify_status\` with those. \`import_and_qualify\` returns \`{status:'running', import_ids}\` and no \`notification_id\` at all \u2014 poll \`leadbay_import_status({importIds, dry_run})\` with those. Poll every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
 
 ## Rule 3 \u2014 Serialize \`leadbay_research_lead_by_id\` fan-out
 
@@ -22573,6 +22068,36 @@ If a Leadbay tool returns \`"Request timed out"\`, \`"stream closed"\`, or any o
 
 If \`pull_leads\` itself fails and you have no prior batch, then yes \u2014 retry it, explicitly pass the lensId you captured (if any), and continue.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 
 # PHASE 0 \u2014 STATE + AUDIENCE
 
@@ -22741,7 +22266,7 @@ Run the Leadbay daily check-in for me. Treat this prompt the same way for any eq
 
 # Resilience rules for Leadbay long-running tools
 
-These four rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
+These rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
 
 ## Rule 1 \u2014 Pin the lens
 
@@ -22749,7 +22274,7 @@ After your first \`leadbay_pull_leads\` call, capture \`response.lens.id\` into
 
 ## Rule 2 \u2014 Prefer async for bulk operations
 
-\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\`, which returns \`{status:'running', qualify_id}\` immediately. Then poll \`leadbay_qualify_status\` (or \`leadbay_import_status\`) every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
+\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\` and return immediately. They hand back different ids: \`bulk_qualify_leads\` returns \`{status:'running', notification_id, lead_ids, lens_id}\` \u2014 poll \`leadbay_qualify_status\` with those. \`import_and_qualify\` returns \`{status:'running', import_ids}\` and no \`notification_id\` at all \u2014 poll \`leadbay_import_status({importIds, dry_run})\` with those. Poll every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
 
 ## Rule 3 \u2014 Serialize \`leadbay_research_lead_by_id\` fan-out
 
@@ -22765,6 +22290,36 @@ If a Leadbay tool returns \`"Request timed out"\`, \`"stream closed"\`, or any o
 
 If \`pull_leads\` itself fails and you have no prior batch, then yes \u2014 retry it, explicitly pass the lensId you captured (if any), and continue.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 
 # PHASE 0 \u2014 RESUME CHECK
 
@@ -22859,7 +22414,7 @@ When the response carries \`social_urls\` (the post-fix multi-platform URL block
 
 ABOVE the table, add a 2\u20134 sentence "Today's nudges" paragraph for the 3 most-promising rows. The nudges speak to urgency / opportunity / freshness \u2014 what makes acting on these RIGHT NOW the right call. Do NOT repeat the "why it fits" column from the table; the nudges should add fresh framing the table doesn't carry (e.g., recent news from the \`qualification_summary\` excerpt, a window closing, a competitor activity the user mentioned earlier in the session). One sentence per nudge, salesperson voice, not coachspeak.
 
-If the batch returns fewer than 10 qualified leads, top it up: call \`leadbay_bulk_qualify_leads\` with \`lensId:<captured>\`, \`count:<1.5x deficit, capped at 25>\`, and **\`wait_for_completion:false\`**. Capture \`qualify_id\` from the response and poll \`leadbay_qualify_status\` every ~10s until \`status:'done'\`. Then re-pull with the same \`lensId\` to pick up the newly qualified leads. **Never re-pull without \`lensId\` \u2014 you will lose your batch to a lens shift.** (The \`leadbay_qualify_top_n\` slash-prompt wraps this same tool with a friendlier surface for users; agents should call the underlying tool directly here.)
+If the batch returns fewer than 10 qualified leads, top it up: call \`leadbay_bulk_qualify_leads\` with \`lensId:<captured>\`, \`count:<1.5x deficit, capped at 25>\`, and **\`wait_for_completion:false\`**. Capture \`notification_id\` from the response and poll \`leadbay_qualify_status\` every ~10s until \`status:'done'\`. Then re-pull with the same \`lensId\` to pick up the newly qualified leads. **Never re-pull without \`lensId\` \u2014 you will lose your batch to a lens shift.** (The \`leadbay_qualify_top_n\` slash-prompt wraps this same tool with a friendlier surface for users; agents should call the underlying tool directly here.)
 
 # PHASE 4 \u2014 DEEP DIVE (every promising lead)
 
@@ -22973,7 +22528,7 @@ If the prompt's body and the tool's RENDERING appear to conflict, the tool's REN
 
 # Resilience rules for Leadbay long-running tools
 
-These four rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
+These rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
 
 ## Rule 1 \u2014 Pin the lens
 
@@ -22981,7 +22536,7 @@ After your first \`leadbay_pull_leads\` call, capture \`response.lens.id\` into
 
 ## Rule 2 \u2014 Prefer async for bulk operations
 
-\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\`, which returns \`{status:'running', qualify_id}\` immediately. Then poll \`leadbay_qualify_status\` (or \`leadbay_import_status\`) every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
+\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\` and return immediately. They hand back different ids: \`bulk_qualify_leads\` returns \`{status:'running', notification_id, lead_ids, lens_id}\` \u2014 poll \`leadbay_qualify_status\` with those. \`import_and_qualify\` returns \`{status:'running', import_ids}\` and no \`notification_id\` at all \u2014 poll \`leadbay_import_status({importIds, dry_run})\` with those. Poll every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
 
 ## Rule 3 \u2014 Serialize \`leadbay_research_lead_by_id\` fan-out
 
@@ -22997,6 +22552,36 @@ If a Leadbay tool returns \`"Request timed out"\`, \`"stream closed"\`, or any o
 
 If \`pull_leads\` itself fails and you have no prior batch, then yes \u2014 retry it, explicitly pass the lensId you captured (if any), and continue.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 
 # THE ONE-FORWARD-OPTION RULE \u2014 the structural contract of this walkthrough
 
@@ -23432,7 +23017,7 @@ account's **default wishlist selection** while \`confirm\`/\`email\` are set \u2
 it would reveal and charge for the whole batch instead of the one lead the user
 agreed to.
 
-It returns a \`bulk_id\` and runs async \u2014 poll \`leadbay_bulk_enrich_status\`
+It returns a \`notification_id\` and runs async \u2014 poll \`leadbay_bulk_enrich_status\`
 with that id (\`include_contacts=true\`) until \`all_done\`, or until the resolved
 count plateaus across a few spaced polls. Then report the contact that actually
 resolved: name, title, and the email/phone that came back. Contacts sometimes
@@ -23670,7 +23255,7 @@ Build the final mappings yourself. Start from \`leadbay_resolve_import_rows.mapp
 
 # PHASE 5 \u2014 QUALIFY (optional) + REPORT
 
-Prefer \`leadbay_import_and_qualify\` when the user asks to qualify/research after import; otherwise use \`leadbay_import_leads\`. For large files or short client timeouts, pass \`wait_for_completion=false\` and poll \`leadbay_import_status\`. After import, qualify only lead IDs returned by the import. Rows that came back \`uncrawled\` are pending a background crawl (not failures); the leads Leadbay adds for them populate in the user's Leadbay account as the crawl completes \u2014 tell the user that, not that a tool call will fetch them (\`import_status\` reports the rows the wizard already placed, not leads a later crawl adds; \`pull_leads\` reads the active lens, so an imported lead outside it may not appear; re-running the import later re-reconciles those companies).
+Prefer \`leadbay_import_and_qualify\` when the user asks to qualify/research after import; otherwise use \`leadbay_import_leads\`. For large files or short client timeouts, pass \`wait_for_completion=false\` and poll \`leadbay_import_status\`. After import, qualify only lead IDs returned by the import. Rows that came back \`uncrawled\` are pending a background crawl (not failures); the leads Leadbay adds for them populate in the user's Leadbay account as the crawl completes \u2014 tell the user that, not that a tool call will fetch them (\`import_status\` refreshes status/progress only; \`pull_leads\` reads the active lens, so an imported lead outside it may not appear; re-running the import later re-reconciles those companies).
 
 **Deliver the augmented file back to the user**: the original file plus a new \`LEADBAY_ID\` column populated from the resolution step. This is the second deliverable of a job well done.
 
@@ -23842,7 +23427,7 @@ You are working with Leadbay through the \`leadbay_*\` MCP tools. This prompt or
 
 # Resilience rules for Leadbay long-running tools
 
-These four rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
+These rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
 
 ## Rule 1 \u2014 Pin the lens
 
@@ -23850,7 +23435,7 @@ After your first \`leadbay_pull_leads\` call, capture \`response.lens.id\` into
 
 ## Rule 2 \u2014 Prefer async for bulk operations
 
-\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\`, which returns \`{status:'running', qualify_id}\` immediately. Then poll \`leadbay_qualify_status\` (or \`leadbay_import_status\`) every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
+\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\` and return immediately. They hand back different ids: \`bulk_qualify_leads\` returns \`{status:'running', notification_id, lead_ids, lens_id}\` \u2014 poll \`leadbay_qualify_status\` with those. \`import_and_qualify\` returns \`{status:'running', import_ids}\` and no \`notification_id\` at all \u2014 poll \`leadbay_import_status({importIds, dry_run})\` with those. Poll every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
 
 ## Rule 3 \u2014 Serialize \`leadbay_research_lead_by_id\` fan-out
 
@@ -23866,6 +23451,36 @@ If a Leadbay tool returns \`"Request timed out"\`, \`"stream closed"\`, or any o
 
 If \`pull_leads\` itself fails and you have no prior batch, then yes \u2014 retry it, explicitly pass the lensId you captured (if any), and continue.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 
 ## The two entry points
 
@@ -24026,7 +23641,7 @@ If the prompt's body and the tool's RENDERING appear to conflict, the tool's REN
 # PHASE 1 \u2014 LAUNCH
 Call \`leadbay_bulk_qualify_leads\` with \`count={{arg:count_or_default}}\` and \`wait_for_completion=true\` (synchronous mode \u2014 waits for results before returning).
 
-**Resilience rule:** If \`leadbay_bulk_qualify_leads\` returns a BulkTracker-not-configured error or similar infrastructure error, do NOT retry with \`wait_for_completion=false\`. Instead, proceed directly to Phase 3 and call \`leadbay_pull_leads\` to surface the already-qualified leads in the current batch.
+**Resilience rule:** If \`leadbay_bulk_qualify_leads\` returns an infrastructure error, do NOT retry with \`wait_for_completion=false\`. Instead, proceed directly to Phase 3 and call \`leadbay_pull_leads\` to surface the already-qualified leads in the current batch.
 
 # PHASE 2 \u2014 POLL
 While it polls, expect notifications / progress events showing per-lead transitions. Surface meaningful ones (e.g. "lead X just finished") to me as they arrive \u2014 one inline status sentence per check, never expanded into a card:
@@ -24525,7 +24140,7 @@ If the prompt's body and the tool's RENDERING appear to conflict, the tool's REN
 
 # Resilience rules for Leadbay long-running tools
 
-These four rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
+These rules apply to every Leadbay workflow that calls \`leadbay_pull_leads\`, \`leadbay_bulk_qualify_leads\`, \`leadbay_research_lead_by_id\`, \`leadbay_import_and_qualify\`, or \`leadbay_enrich_titles\`. **Treat timeouts and stream-closed errors as transient, not as signals to replan.**
 
 ## Rule 1 \u2014 Pin the lens
 
@@ -24533,7 +24148,7 @@ After your first \`leadbay_pull_leads\` call, capture \`response.lens.id\` into
 
 ## Rule 2 \u2014 Prefer async for bulk operations
 
-\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\`, which returns \`{status:'running', qualify_id}\` immediately. Then poll \`leadbay_qualify_status\` (or \`leadbay_import_status\`) every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
+\`leadbay_bulk_qualify_leads\` and \`leadbay_import_and_qualify\` accept \`wait_for_completion:false\` and return immediately. They hand back different ids: \`bulk_qualify_leads\` returns \`{status:'running', notification_id, lead_ids, lens_id}\` \u2014 poll \`leadbay_qualify_status\` with those. \`import_and_qualify\` returns \`{status:'running', import_ids}\` and no \`notification_id\` at all \u2014 poll \`leadbay_import_status({importIds, dry_run})\` with those. Poll every ~10s until the job completes. **Use the async pattern by default** \u2014 the blocking default can exceed the MCP client's per-call timeout on large batches and produce a misleading \`"Request timed out"\` even though the server is still working.
 
 ## Rule 3 \u2014 Serialize \`leadbay_research_lead_by_id\` fan-out
 
@@ -24549,6 +24164,36 @@ If a Leadbay tool returns \`"Request timed out"\`, \`"stream closed"\`, or any o
 
 If \`pull_leads\` itself fails and you have no prior batch, then yes \u2014 retry it, explicitly pass the lensId you captured (if any), and continue.
 
+## A launched job cannot be stopped
+
+Leadbay has no cancel. Once \`leadbay_enrich_titles\`, \`leadbay_bulk_qualify_leads\`,
+\`leadbay_import_leads\` or \`leadbay_import_and_qualify\` has returned a launched or
+running result, that work is queued on Leadbay and runs to completion, and the
+quota it costs is already committed. A discovery, preview or \`dry_run\` result
+launched nothing and is not covered here.
+
+The user cancelling in the chat, a request timeout, or a closed stream stops YOUR
+waiting, never the job. \`cancelled: true\` means we stopped watching, not that the
+work stopped. What to do next depends on what you are holding:
+
+- **A handle.** Poll the status tool with it, and do not launch the work that
+  handle covers a second time \u2014 that spends the quota again on the same rows.
+  \`leadbay_import_status\` takes \`importIds\`, so pass the values of \`import_ids\`
+  under that name. A qualification started by \`leadbay_import_and_qualify\` has no
+  notification of its own: resume it with
+  \`leadbay_qualify_status({lead_ids, lens_id})\`.
+- **A handle AND a subset the result says never started** \u2014 \`failed[]\` entries
+  with \`error:"not_queued"\`, or a \`rows_pending_upload\` count. Poll the handle
+  for what was launched and re-run for that subset only, never for the whole
+  batch.
+- **No result at all**, because the call timed out or the stream closed before it
+  returned. Check \`leadbay_account_status\` first: the launch may have landed and
+  finished. Calling the same tool again with the same arguments will usually hand
+  back the job already launched rather than starting a second one, but that guard
+  is in-memory, five minutes, and per process, so it is best-effort \u2014 say what you
+  are about to re-run before you spend the user's quota on it.
+
+
 
 # PHASE 0 \u2014 SCOPE + STATE
 
@@ -24646,7 +24291,7 @@ So: **read the persisted filter first** (the response reports \`active_filters\`
 
 \u26A0 **Pass explicit \`leadIds\` whenever the cohort isn't simply "the next N on the lens"** \u2014 e.g. after you've selected a shortlist, or when the plan mixes Monitor and Discover rows. The \`count\`-based path selects the next *unqualified leads from the lens wishlist*, so on any other cohort it qualifies unrelated leads and hands you handles whose pills belong to different companies. Use \`leadbay_bulk_qualify_leads({leadIds:[\u2026\u226425 of the cohort], wait_for_completion:false})\` and chunk through the cohort's own ids. The \`{lensId, count}\` form is only right when the cohort genuinely *is* the lens's top N.
 
-**Qualify the plan cohort, not the whole base.** Select your ~{{arg:count_or_default}} candidates (plus a modest buffer for drop-outs) BEFORE qualifying \u2014 qualification is async and quota-bearing, so running it across an entire portfolio to produce a top-{{arg:count_or_default}} burns the user's quota for rows that will never appear. **Keep every returned \`qualify_id\`** \u2014 the deck's live qualification layer is wired from those handles, and a deck with none is a dead deck that still looks finished. Never ship a plan whose lower ranks have empty qualification pills because only the first 25 were ever qualified.
+**Qualify the plan cohort, not the whole base.** Select your ~{{arg:count_or_default}} candidates (plus a modest buffer for drop-outs) BEFORE qualifying \u2014 qualification is async and quota-bearing, so running it across an entire portfolio to produce a top-{{arg:count_or_default}} burns the user's quota for rows that will never appear. **Keep every returned \`notification_id\`** \u2014 the deck's live qualification layer is wired from those handles, and a deck with none is a dead deck that still looks finished. Never ship a plan whose lower ranks have empty qualification pills because only the first 25 were ever qualified.
 
 **Signals \u2014 scoped to the cohort.** \u26A0 **Always pass the selected \`leadIds\`.** With \`leadIds\` omitted, \`leadbay_scan_portfolio_signals\` builds its own portfolio by paging \`/monitor\` \u2014 so on an imported cohort or a freshly-pulled Discover set it would scan a *different population* and you'd render dashes for accounts whose signals were never read.
 
@@ -24773,7 +24418,7 @@ Each card needs a reachable decision-maker. \`leadbay_enrich_titles({leadIds, le
 
 \u26A0 **Do NOT quote a cost or a credits figure.** The per-reveal rate is backend-side and enrichment is gated by quota, not a credit balance; \`credits_remaining\` is advisory context only. A spend number invented to make the offer concrete is the same failure as an invented euro on a card.
 
-On an explicit yes, launch with the agreed \`titles\` + channels, then poll \`leadbay_bulk_enrich_status\` until done and **keep the \`bulk_id\` handles** for the deck.
+On an explicit yes, launch with the agreed \`titles\` + channels, then poll \`leadbay_bulk_enrich_status\` until done and **keep the \`notification_id\` handles** for the deck.
 
 \u26A0 **Render only the channels that actually came back.** The default reveal is email-only unless phone was explicitly requested, so never emit a \`tel:\` link for a contact whose phone was never revealed \u2014 show the channels enrichment returned and mark the rest omitted. A fabricated phone link is the same failure as a fabricated euro.
 
@@ -24919,9 +24564,9 @@ ChatGPT exposes the same routing pattern via \`_meta.openai/outputTemplate\`. We
 - One short intro sentence in chat is enough \u2014 "Here are your 5 NYC follow-ups." Then route into the widget.
 
 
-\u26A0 **The deck's contact layer depends on what actually happened in Phase 5.** Bind a \`leadbay_bulk_enrich_status\` resource ONLY if a paid reveal was launched and you hold a \`bulk_id\`. If the user accepted the deck but not the reveal, render the contacts already on record and carry the paid-reveal offer inside the deck \u2014 never wire a status resource with no handle (it renders permanently empty) and never launch enrichment from the deck to manufacture one.
+\u26A0 **The deck's contact layer depends on what actually happened in Phase 5.** Bind a \`leadbay_bulk_enrich_status\` resource ONLY if a paid reveal was launched and you hold a \`notification_id\`. If the user accepted the deck but not the reveal, render the contacts already on record and carry the paid-reveal offer inside the deck \u2014 never wire a status resource with no handle (it renders permanently empty) and never launch enrichment from the deck to manufacture one.
 
-On acceptance, call \`leadbay_artifact_kit\`, read its \`usage_guide\` before writing any code, and build a single-file deck. Wire the live layer from the handles you kept: a poll-until-done resource per \`qualify_id\` for the qualification pills, and one over \`leadbay_bulk_enrich_status\` for the contacts. \u26A0 **If enrichment already ran this session, bind the existing \`bulk_id\` \u2014 re-launching enrichment from the deck double-spends my quota.** Per-card notes and outcomes go through the pre-wired note/outreach view-models (they carry the required verification and \`_triggered_by\` fields; hand-rolling those is where it breaks). Keep the checklists in local storage, and always wire a Refresh \u2014 auto-poll is host-dependent. List every tool the deck calls in its \`mcp_tools\`, and render the bridge-unavailable branch, or the pills silently show empty.
+On acceptance, call \`leadbay_artifact_kit\`, read its \`usage_guide\` before writing any code, and build a single-file deck. Wire the live layer from the handles you kept: a poll-until-done resource per \`notification_id\` for the qualification pills, and one over \`leadbay_bulk_enrich_status\` for the contacts. \u26A0 **If enrichment already ran this session, bind the existing \`notification_id\` \u2014 re-launching enrichment from the deck double-spends my quota.** Per-card notes and outcomes go through the pre-wired note/outreach view-models (they carry the required verification and \`_triggered_by\` fields; hand-rolling those is where it breaks). Keep the checklists in local storage, and always wire a Refresh \u2014 auto-poll is host-dependent. List every tool the deck calls in its \`mcp_tools\`, and render the bridge-unavailable branch, or the pills silently show empty.
 
 # Iron laws
 
@@ -26197,7 +25842,7 @@ function buildProtocolPrimitivesParagraph(has) {
   }
   if (longRunners.length > 0) {
     parts.push(
-      "(2) `notifications/cancelled` \u2014 when the user clicks Cancel in the host UI, the polling loop exits within \u22642 seconds AND the bulk-store entry transitions to 'cancelled'; subsequent status polls return `BULK_CANCELLED` so the agent stops polling."
+      "(2) `notifications/cancelled` \u2014 when the user clicks Cancel in the host UI, the polling loop exits within \u22642 seconds. The job itself keeps running on the backend; poll its notification_id / importIds later to pick it up."
     );
   } else {
     parts.push(
@@ -26717,7 +26362,6 @@ ${url}
       const shapeError = findShapeMismatch(tool, args);
       const result = shapeError ?? await runWithRequestSignal(extra.signal, () => tool.execute(client, args, {
         logger: opts.logger,
-        bulkTracker: opts.bulkTracker,
         notificationsInbox: opts.notificationsInbox,
         signal: extra.signal,
         progress,
@@ -26971,10 +26615,10 @@ ${url}
 import { spawn } from "child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
 import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir } from "os";
 var HOSTED_MCP_URL_CHATGPT = "https://mcp.leadbay.app/chatgpt/mcp";
-function formatInstallOsLabel(platform2 = process.platform, arch = process.arch) {
-  const name = platform2 === "darwin" ? "macOS" : platform2 === "win32" ? "Windows" : platform2 === "linux" ? "Linux" : platform2;
+function formatInstallOsLabel(platform = process.platform, arch = process.arch) {
+  const name = platform === "darwin" ? "macOS" : platform === "win32" ? "Windows" : platform === "linux" ? "Linux" : platform;
   return `${name} (${arch})`;
 }
 function detectClaudeDesktopMode(claudeSupportDir) {
@@ -27089,7 +26733,7 @@ async function isCursorInstalled(home) {
 }
 async function detectClients() {
   const out = [];
-  const home = homedir2();
+  const home = homedir();
   const claudeBin = await findOnPath("claude");
   if (claudeBin) {
     out.push({ id: "claude-code", label: "Claude Code", detail: `${claudeBin} mcp add ...` });
@@ -27198,7 +26842,7 @@ async function uninstallFromClaudeCode() {
 async function installInJsonConfig(configPath, token, region, includeWrite, telemetryEnabled, localBinPath) {
   try {
     const { readFileSync: readFileSync3, writeFileSync, existsSync: existsSync4, mkdirSync, statSync } = await import("fs");
-    const { dirname: dirname3 } = await import("path");
+    const { dirname: dirname2 } = await import("path");
     let parsed = {};
     let preserved = {};
     const existed = existsSync4(configPath);
@@ -27211,7 +26855,7 @@ async function installInJsonConfig(configPath, token, region, includeWrite, tele
         return { ok: false, message: `existing ${configPath} is not valid JSON; refusing to overwrite` };
       }
     } else {
-      mkdirSync(dirname3(configPath), { recursive: true });
+      mkdirSync(dirname2(configPath), { recursive: true });
     }
     parsed.mcpServers = parsed.mcpServers ?? {};
     const env = {
@@ -27336,13 +26980,13 @@ function stripShellExportBlock(existing) {
 async function installInCodexConfig(configPath, includeWrite, telemetryEnabled, localBinPath) {
   try {
     const { readFileSync: readFileSync3, writeFileSync, existsSync: existsSync4, mkdirSync, statSync, renameSync, chmodSync } = await import("fs");
-    const { dirname: dirname3 } = await import("path");
+    const { dirname: dirname2 } = await import("path");
     let existing = "";
     const existed = existsSync4(configPath);
     if (existed) {
       existing = readFileSync3(configPath, "utf8");
     } else {
-      mkdirSync(dirname3(configPath), { recursive: true });
+      mkdirSync(dirname2(configPath), { recursive: true });
     }
     const hadLeadbayConfig = /(^|\r?\n)\[mcp_servers\.leadbay\]\r?\n/.test(existing);
     const next = mergeCodexConfig(
@@ -27660,17 +27304,17 @@ function parseWriteEnv(env = process.env) {
 
 // src/update-state.ts
 import {
-  mkdir as mkdirAsync2,
-  lstat as lstat2,
-  open as fsOpen2,
-  readFile as readFile2,
-  rename as rename2,
-  stat as stat2,
-  unlink as unlink2
+  mkdir as mkdirAsync,
+  lstat,
+  open as fsOpen,
+  readFile,
+  rename,
+  stat,
+  unlink
 } from "fs/promises";
-import { constants as fsConstants2 } from "fs";
-import { dirname as dirname2, resolve as resolvePath2 } from "path";
-import { homedir as homedir3 } from "os";
+import { constants as fsConstants } from "fs";
+import { dirname, resolve as resolvePath } from "path";
+import { homedir as homedir2 } from "os";
 function emptyState() {
   return {
     last_check_time: 0,
@@ -27694,7 +27338,7 @@ var UpdateStateStore = class {
       if (!opts.path) {
         throw new Error("UpdateStateStore: path is required when backend=file");
       }
-      this.path = resolvePath2(opts.path);
+      this.path = resolvePath(opts.path);
       this.validatePath(this.path);
     }
   }
@@ -27706,7 +27350,7 @@ var UpdateStateStore = class {
   }
   validatePath(p) {
     if (this.allowUnsafePath) return;
-    const home = resolvePath2(homedir3());
+    const home = resolvePath(homedir2());
     if (p !== home && !p.startsWith(home + "/") && !p.startsWith(home + "\\")) {
       throw new Error(
         `UpdateStateStore: path ${p} is outside $HOME (${home}). Set LEADBAY_UPDATE_STATE_PATH_UNSAFE=1 to override.`
@@ -27718,10 +27362,10 @@ var UpdateStateStore = class {
       this.initialized = true;
       return;
     }
-    const dir = dirname2(this.path);
-    await mkdirAsync2(dir, { recursive: true, mode: 448 });
+    const dir = dirname(this.path);
+    await mkdirAsync(dir, { recursive: true, mode: 448 });
     try {
-      const st = await lstat2(this.path);
+      const st = await lstat(this.path);
       if (st.isSymbolicLink()) {
         throw new Error(
           `UpdateStateStore: refusing to use ${this.path} \u2014 path is a symlink. Set LEADBAY_UPDATE_STATE_PATH_UNSAFE=1 to override.`
@@ -27737,7 +27381,7 @@ var UpdateStateStore = class {
     await this.ensureInitialized();
     let raw;
     try {
-      raw = await readFile2(this.path, "utf8");
+      raw = await readFile(this.path, "utf8");
     } catch (err) {
       if (err?.code === "ENOENT") return emptyState();
       throw err;
@@ -27759,13 +27403,13 @@ var UpdateStateStore = class {
     }
     await this.ensureInitialized();
     const tmp = `${this.path}.tmp.${process.pid}.${this.now()}`;
-    const handle = await openTmpFileExclusive2(tmp);
+    const handle = await openTmpFileExclusive(tmp);
     try {
       await handle.writeFile(JSON.stringify(state, null, 2));
     } finally {
       await handle.close();
     }
-    await rename2(tmp, this.path);
+    await rename(tmp, this.path);
   }
   /**
    * Apply a partial mutation atomically (read → merge → write). Caller
@@ -27811,20 +27455,20 @@ var UpdateStateStore = class {
     return out;
   }
 };
-async function openTmpFileExclusive2(path) {
+async function openTmpFileExclusive(path) {
   try {
-    return await fsOpen2(
+    return await fsOpen(
       path,
-      fsConstants2.O_CREAT | fsConstants2.O_WRONLY | fsConstants2.O_EXCL,
+      fsConstants.O_CREAT | fsConstants.O_WRONLY | fsConstants.O_EXCL,
       384
     );
   } catch (err) {
     if (err?.code === "EEXIST") {
-      await unlink2(path).catch(() => {
+      await unlink(path).catch(() => {
       });
-      return fsOpen2(
+      return fsOpen(
         path,
-        fsConstants2.O_CREAT | fsConstants2.O_WRONLY | fsConstants2.O_EXCL,
+        fsConstants.O_CREAT | fsConstants.O_WRONLY | fsConstants.O_EXCL,
         384
       );
     }
@@ -27834,7 +27478,7 @@ async function openTmpFileExclusive2(path) {
 async function createDefaultUpdateStateStore(opts = {}) {
   const env = opts.env ?? process.env;
   const allowUnsafePath = env.LEADBAY_UPDATE_STATE_PATH_UNSAFE === "1";
-  const path = env.LEADBAY_UPDATE_STATE_PATH ?? resolvePath2(homedir3(), ".leadbay", "update-state.json");
+  const path = env.LEADBAY_UPDATE_STATE_PATH ?? resolvePath(homedir2(), ".leadbay", "update-state.json");
   try {
     const store = new UpdateStateStore({
       backend: "file",
@@ -27843,7 +27487,7 @@ async function createDefaultUpdateStateStore(opts = {}) {
       allowUnsafePath
     });
     await store.ensureInitialized();
-    await stat2(dirname2(path));
+    await stat(dirname(path));
     return store;
   } catch (err) {
     opts.logger?.warn?.(
@@ -28154,14 +27798,14 @@ async function exchangeCodeForToken(opts) {
   return { accessToken: parsed.access_token };
 }
 function browserOpenCandidates(url) {
-  const platform2 = process.platform;
-  if (platform2 === "darwin") {
+  const platform = process.platform;
+  if (platform === "darwin") {
     return [
       { cmd: "/usr/bin/open", args: [url] },
       { cmd: "open", args: [url] }
     ];
   }
-  if (platform2 === "win32") {
+  if (platform === "win32") {
     const sysRoot = process.env.SystemRoot || process.env.windir || "C:\\Windows";
     const cmdExe = `${sysRoot}\\System32\\cmd.exe`;
     const quoted = `"${url}"`;
@@ -28401,7 +28045,7 @@ var OAUTH_BASE_URLS = {
     fr: "https://staging.api.leadbay.app"
   }
 };
-var VERSION = "0.34.1";
+var VERSION = "0.35.1";
 var HELP = `
 leadbay-mcp ${VERSION} \u2014 Leadbay Model Context Protocol server
 
@@ -28524,9 +28168,9 @@ function hydrateEnvFromCredentialsFile() {
 function resolveOAuthBootstrapCredentialsPath() {
   const resolved = resolveDefaultCredentialsPath();
   if (process.env.LEADBAY_OAUTH_STAGING !== "1") return resolved;
-  const { dirname: dirname3, join: join3 } = require_("node:path");
+  const { dirname: dirname2, join: join3 } = require_("node:path");
   return {
-    path: join3(dirname3(resolved.path), "credentials.staging.json"),
+    path: join3(dirname2(resolved.path), "credentials.staging.json"),
     legacy: resolved.legacy
   };
 }
@@ -28537,8 +28181,8 @@ function bootstrapDebug(msg) {
   try {
     const { appendFileSync, mkdirSync } = require_("node:fs");
     const { join: join3 } = require_("node:path");
-    const { homedir: homedir4 } = require_("node:os");
-    const dir = join3(homedir4(), ".leadbay");
+    const { homedir: homedir3 } = require_("node:os");
+    const dir = join3(homedir3(), ".leadbay");
     mkdirSync(dir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(join3(dir, "oauth-bootstrap-debug.log"), `${ts} [pid ${process.pid}] ${msg}
@@ -28548,8 +28192,8 @@ function bootstrapDebug(msg) {
 }
 function oauthClientCachePath() {
   const { join: join3 } = require_("node:path");
-  const { homedir: homedir4 } = require_("node:os");
-  return join3(homedir4(), ".leadbay", "oauth-client.json");
+  const { homedir: homedir3 } = require_("node:os");
+  return join3(homedir3(), ".leadbay", "oauth-client.json");
 }
 function getCachedOAuthClientId(authServerBaseUrl, port) {
   try {
@@ -28565,7 +28209,7 @@ function getCachedOAuthClientId(authServerBaseUrl, port) {
 function cacheOAuthClientId(authServerBaseUrl, clientId, port) {
   try {
     const { readFileSync: readFileSync3, writeFileSync, mkdirSync } = require_("node:fs");
-    const { dirname: dirname3 } = require_("node:path");
+    const { dirname: dirname2 } = require_("node:path");
     const path = oauthClientCachePath();
     let data = { clients: {} };
     try {
@@ -28577,7 +28221,7 @@ function cacheOAuthClientId(authServerBaseUrl, clientId, port) {
     const byPort = server && typeof server === "object" && server.byPort && typeof server.byPort === "object" ? server.byPort : {};
     byPort[String(port)] = clientId;
     data.clients[authServerBaseUrl] = { byPort };
-    mkdirSync(dirname3(path), { recursive: true });
+    mkdirSync(dirname2(path), { recursive: true });
     writeFileSync(path, JSON.stringify(data, null, 2) + "\n", { mode: 384 });
   } catch {
   }
@@ -28670,7 +28314,7 @@ async function bootstrapOAuthIfMissing(logger) {
     });
     try {
       const { writeFileSync, mkdirSync, chmodSync } = require_("node:fs");
-      const { dirname: dirname3 } = require_("node:path");
+      const { dirname: dirname2 } = require_("node:path");
       const { path } = resolveOAuthBootstrapCredentialsPath();
       const envBlock = {
         LEADBAY_TOKEN: accessToken,
@@ -28686,7 +28330,7 @@ async function bootstrapOAuthIfMissing(logger) {
           }
         }
       };
-      mkdirSync(dirname3(path), { recursive: true });
+      mkdirSync(dirname2(path), { recursive: true });
       writeFileSync(path, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
       try {
         chmodSync(path, 384);
@@ -29127,8 +28771,8 @@ Restart your MCP client to pick up the new server.
   let actualMode;
   try {
     const { writeFileSync, chmodSync, mkdirSync, renameSync, statSync, unlinkSync } = await import("fs");
-    const { dirname: dirname3 } = await import("path");
-    mkdirSync(dirname3(targetPath), { recursive: true });
+    const { dirname: dirname2 } = await import("path");
+    mkdirSync(dirname2(targetPath), { recursive: true });
     const tmp = targetPath + ".tmp." + process.pid;
     writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", {
       encoding: "utf8",
@@ -29586,7 +29230,6 @@ async function main() {
   });
   const includeAdvanced = process.env.LEADBAY_MCP_ADVANCED === "1";
   const includeWrite = parseWriteEnv();
-  const bulkTracker = await createDefaultBulkStore({ logger });
   const updateStateStore = await createDefaultUpdateStateStore({ logger });
   void recordRunningVersion(VERSION, updateStateStore, telemetry).catch((err) => {
     logger.warn?.(
@@ -29623,7 +29266,6 @@ async function main() {
     includeAdvanced,
     includeWrite,
     logger,
-    bulkTracker,
     notificationsInbox,
     version: VERSION,
     telemetry,
@@ -29643,7 +29285,7 @@ async function main() {
   });
   const transport = new StdioServerTransport();
   logger.info?.(
-    `Starting MCP server v${VERSION} (advanced=${includeAdvanced}, write=${includeWrite}, baseUrl=${client.baseUrl}, bulk_store=${bulkTracker.durability}, notifications_ws=${WS_DISABLED ? "disabled" : "enabled"}, auth_state=${authState})`
+    `Starting MCP server v${VERSION} (advanced=${includeAdvanced}, write=${includeWrite}, baseUrl=${client.baseUrl}, notifications_ws=${WS_DISABLED ? "disabled" : "enabled"}, auth_state=${authState})`
   );
   await server.connect(transport);
   if (bootstrapPending) {