@leadbay/mcp 0.36.0 → 0.37.0

package/dist/http-server.js

@@ -1309,6 +1309,170 @@ After I answer, call \`leadbay_report_outreach({lead_id: '{{arg:lead_id}}', note
 # PHASE 3 \u2014 CONFIRM
 Tell me the outreach was logged, name the verification.source used, and surface the response's \`outreach_id\` if present so I can refer back to it.
 `;
+var leadbay_new_leads = `
+## WHAT LEADBAY SHOULD REMEMBER
+
+You keep your own memory of how this user likes to work \u2014 tone, naming, formatting, what they ask you to skip. Leadbay does not store that and does not need to.
+
+What Leadbay does need is anything that changes **who it should find**. When the user states targeting criteria in conversation ("I target fleets over 100 vehicles", "carriers are a bad fit unless they do last-mile delivery", "climate engineering is also my market"), call \`leadbay_refine_prompt\` so it changes what Leadbay surfaces for the whole org and on every future refresh \u2014 not just this conversation. When they say a specific lead is wrong for them, record the dislike rather than noting it.
+
+
+IRON LAW \u2014 NO FABRICATION. Every lead id, contact email, custom field id, mapping decision, and tool argument must trace to a value you read from the file the user attached or to an output from a leadbay_* tool call in this session. Do not invent values. Do not "fill in" a missing leadId with a name match. Do not synthesize a CRM id from a guess. If a value is missing, leave the field blank and say so.
+
+
+GATE \u2014 DEFER TO TOOL RENDERING. When you call a Leadbay composite that ships its own RENDERING block (every composite in 0.9.0+ does), render the response using that block's recipe verbatim \u2014 score bars, glyph palette, column order, hide-list, link priorities, all of it. Do NOT substitute prose, a numbered list, or a different column structure even when an orchestrating prompt's body suggests alternate framing. Prompt-specific commentary (motivational nudges, summaries, next-action recommendations) belongs ABOVE or BELOW the canonical table, never in place of it.
+
+If the prompt's body and the tool's RENDERING appear to conflict, the tool's RENDERING wins for the structural layout; the prompt's voice wins for the commentary that surrounds it.
+
+
+**First, check \`leadbay_find_new_leads\` is in your tool set.** Every phase below
+calls it or \`leadbay_qualify_leads\`, and both are write-tier: on a read-only
+deployment (\`LEADBAY_MCP_WRITE=0\`) neither is registered. The MCP prompt hides
+itself there; this file is a static Claude skill with no runtime gate, so the
+check has to be here. If they're missing: say plainly that net-new search isn't
+enabled on this connection, and offer \`leadbay_pull_leads\` for today's batch
+instead. Starting a workflow whose first call does not exist is worse than
+saying so up front.
+
+Find net-new leads for me. My need, in my words:
+
+> {{arg:need}}
+
+If that need was not supplied to you directly, take it from the message that
+started this \u2014 the request in my own words is the need, and I should never be
+asked to repeat something I already said. Only when BOTH are missing or too
+vague to name (a) who I sell to and (b) roughly how many leads I want, ask me
+ONCE \u2014 one short question \u2014 then proceed. Default count when unstated: 10.
+
+# PHASE 1 \u2014 UNDERSTAND THE BUYER (no tool calls yet)
+
+From my words, work out:
+- What I SELL and therefore WHO WRITES ME CHECKS \u2014 the buyer category, never
+  the buyer's customers, never my competitors. If my product helps companies
+  of type X serve audience Y, my buyer is X.
+- Hard constraints: geography, size band, sector, exclusions ("no
+  franchises", "pas de grands groupes" \u2014 negatives BIND).
+- Contact needs: do I want a person? Which titles? Email, phone, both?
+- Buyer archetypes: if my need genuinely spans two different kinds of buyer,
+  plan one search per archetype \u2014 never one blended seed.
+
+# PHASE 2 \u2014 CRAFT THE SEED
+
+Compose the \`example_lead\` for each archetype following the craft rules in
+the leadbay_find_new_leads description (registry-style description of a
+FICTIONAL typical buyer; no invented brand name; no event language; hard
+constraints go in \`filters\` with the FLAT keys \`employees_min\`/\`employees_max\`
+and city/state/region \`locations\` \u2014 never a country name). Show me the seed
+description(s) in one line each \u2014 I should recognize my ideal customer in
+them.
+
+\`filters\` only encodes sectors, locations and employee bounds. Any constraint
+that does not fit those keys \u2014 above all EXCLUSIONS like "no franchises" or
+"pas de grands groupes" \u2014 has nowhere to live in the filter schema, so it must
+not be dropped on the floor: express it positively in the seed \`description\`
+(an independent single-site operator rather than "no franchises"), and carry
+the exclusion forward yourself to Phase 5, where you drop violating rows and
+say you dropped them. Tell me plainly if a constraint can only be enforced
+that way \u2014 after the fact, not by the search.
+
+Composing this fictional seed from my words is expected and permitted: it is
+the tool's designed input, not fabricated data. What must never be invented is
+a RESULT \u2014 company names, contacts, scores, or anything presented as coming
+back from Leadbay.
+
+# PHASE 3 \u2014 FREE PREVIEW
+
+Call \`leadbay_find_new_leads\` with the seed, \`filters\`, \`count\`,
+\`qualify: false\`, no channels \u2014 this is FREE \u2014 and a \`request_id\` derived
+from the ask + the ARCHETYPE + today's date. \`count\` is the TOTAL I asked
+for, not a per-search number: with two archetypes and a request for 10,
+split it (5 + 5, or whatever weighting fits my ask) rather than sending 10
+to each \u2014 otherwise I get 20 leads and, on the paid pass, pay for 20.
+
+When you RETRY a search \u2014 it timed out, or the job is still live \u2014 reuse the
+\`request_id\` you already sent, verbatim. Do not recompute it: rederiving from
+"today's date" after midnight yields a new key, the backend cannot dedupe, and
+a second paid, novelty-claiming search launches. Roll the date only when I am
+genuinely asking for a new batch. The archetype component is not
+optional: \`request_id\` is the idempotency key, so two archetype searches
+sharing one id dedupe to the same job and the second archetype is never
+searched. Render the delivery table and judge fit honestly: are these the
+kind of companies I asked for?
+
+- **\`still_running: true\`** \u2192 the job is ALIVE. Do not judge the seed and do
+  not relaunch \u2014 poll \`leadbay_lead_job_status\` (\`wait_seconds: 60\`) until
+  it goes terminal, reporting progress. Relaunching now burns an active-job
+  slot and rate-limit budget on a search that may be about to deliver.
+- **On-profile** (terminal) \u2192 offer Phase 4.
+- **Off-profile or empty** (terminal) \u2192 read \`funnel\` +
+  \`explain.scope_notes\`, tell me what went wrong in one line (wrong
+  archetype? too narrow a filter? thin universe?), reshape the seed or
+  filters, and retry under a NEW request_id. Reshaping is free; do not pay
+  to explore a bad seed.
+
+# PHASE 4 \u2014 PAID DEPTH (only with my explicit go-ahead)
+
+When I want qualification evidence and/or reachable contacts:
+1. Quote first: \`dry_run: true\` on the tool you will actually run, with the
+   exact flags I asked for, and tell me the worst-case cost in plain money.
+   The two tools take DIFFERENT flags \u2014 passing the wrong one is rejected
+   outright (\`additionalProperties: false\`):
+   - \`leadbay_qualify_leads\`: \`qualify: true\`, \`contact_titles\`,
+     \`title_gate\`, \`channels\`, \`max_cost\`. **No \`min_ai_score\`.**
+   - \`leadbay_find_new_leads\`: the same, PLUS \`min_ai_score\` and \`count\`.
+2. On my go-ahead, prefer feeding the free preview's deliveries to
+   \`leadbay_qualify_leads\` (\`prior_deliveries: {job_id}\`) \u2014 one paid pass PER
+   preview job when Phase 3 ran several archetypes, or merge their delivered
+   refs into a single \`lead_refs\` call. Never qualify just the first job and
+   call it done: the other archetypes are part of what I asked for. It only
+   spends on
+   companies already known to match. Paid calls need \`confirm: true\`; without
+   it the tool withholds the submit and hands back a quote instead of
+   spending. That applies to \`leadbay_find_new_leads\` too whenever you set
+   \`qualify: true\` or ask for channels.
+
+   If the preview delivered FEWER than I asked for, do both halves and do not
+   conflate them: qualify what the preview already found, and run the fresh
+   search only for the SHORTFALL \u2014 \`count\` = what is still missing, never the
+   original number, under a NEW \`request_id\`. Reusing the preview's id dedupes
+   the paid submit back into the free job; keeping the original count buys a
+   whole second batch, because \`novelty: org\` already excludes everything the
+   preview delivered.
+
+   The same arithmetic applies AFTER the paid pass. A full-count preview can
+   still end short once qualification disqualifies rows or a strict title /
+   channel match misses: what I asked for is n QUALIFIED, CONTACTABLE leads,
+   not n examined. Count the delivered-and-callable rows; if they fall short,
+   tell me the gap in one line and offer to top it up \u2014 another shortfall-sized
+   search under a NEW \`request_id\`, quoted first like any paid run. Never
+   silently hand back fewer than I asked for and paid toward.
+
+   Pass the leads already EXAMINED-AND-REJECTED into that top-up's
+   \`exclude_lead_ids\` \u2014 disqualified and skipped, from both the preview and
+   the paid pass. \`novelty: org\` already excludes prior DELIVERIES, so
+   delivered ids are redundant there; the rejected ones are exactly what it
+   misses, and without them the top-up re-picks the same misses and charges
+   again to close no gap. **\`exclude_lead_ids\` caps at 500** \u2014 a wide
+   \`exploration_cap\` can examine more than that, so send the most recent 500
+   rejects rather than an over-long list the tool refuses outright.
+3. While the job runs, poll with \`leadbay_lead_job_status\`
+   (\`wait_seconds: 60\`); report progress, not silence.
+
+# PHASE 5 \u2014 DELIVER
+
+Before rendering, sanity-check every row: geography inside my fence (drop
+and call out same-named-city leaks), descriptions actually matching my ask
+(especially when \`explain.seed_strategy\` is \`text_match_exemplars\` \u2014 fit
+scores run hot there), visible violations of my exclusions dropped. If the
+best fit is under 30, say "weak matches only" and propose reshaping before
+showing more than 3.
+
+Render per the lead-delivery table, then ALWAYS the funnel line: matched /
+examined / qualified / disqualified / delivered / stop reason / spend. Zero
+delivered gets a diagnosis and a concrete next move, never a shrug. Close
+with NEXT STEPS from the tool description \u2014 and STOP; take no further action
+without my say-so.
+`;
 var leadbay_plan_tour_in_city = `
 Plan a field sales tour for me in **{{arg:city}}**{{arg:date_paren}}.
 
@@ -2702,6 +2866,14 @@ that's leadbay_prospecting_overview.
 `, "arguments": [], "expected_calls": ["leadbay_account_status", "leadbay_pull_leads", "leadbay_prepare_outreach", "leadbay_enrich_titles", "leadbay_bulk_enrich_status"], "failure_modes": ['Presents a gate as prose ("let me know if you want me to pull your leads") instead of CALLING the host choice widget \u2014 the click IS the lesson, and prose turns the walkthrough into a lecture', "Runs a step's tool WITHOUT firing that step's widget first and waiting for the click \u2014 the walkthrough becomes an automated demo the user only watches, which is the exact opposite of learning by doing", "Fires the widget without the EXPLAIN beat, so the user gets an unexplained button and learns nothing about what a lens or an enrichment actually is", 'Answers gate 1 with a bare "you\'re connected as X at Y" when the quota IS readable \u2014 the user clicked a button labelled `check my account status`, so the quota windows (Daily/Weekly/Monthly gauges, % used, $ spent, resets) ARE the answer, not an optional extra', 'Renders quota as raw "credits" instead of the web app\'s percentage + dollar-spend gauges, or dumps raw `resource_type` strings the user has never seen', "Opens with a wall of text \u2014 previewing all four steps, explaining lenses up front, or writing several paragraphs before the first widget. The opening is TWO lines then the button; a first-run user wants to see it work, not read a syllabus", `Ends the first message without firing gate 1's widget, leaving the user to reply "ok" before anything happens`, "Rewrites the gate's own `next_steps` payload (its `question`, `label` or `description`) instead of mapping it into the widget verbatim, or merges two gates into a single multi-option widget", 'Fires a THIRD option, or turns the exit into an alternative route ("show me my lenses instead") \u2014 each gate carries exactly one forward action plus the `I\'m done for now` exit, never a menu of paths', `Fires a single-option widget \u2014 the host requires 2\u20134 options, so a lone option is rejected or silently degrades to prose ("say the word and I'll check it"), which is the exact defect this rule exists to prevent`, 'Launches the PAID reveal at gate 4 BEFORE the user has picked leads and confirmed \u2014 beat 1 must be the free `mode:"discover"` preview (no `titles`, no `confirm`, no `email`, no `phone`); the gate click bought the free look, not the reveal, and silence is never consent', "Stops at the free preview after the user DID pick leads and confirm \u2014 they asked for real contact details, so the second call must actually run with `confirm:true` and the chosen titles", "Reports the enrichment without polling `leadbay_bulk_enrich_status` to completion, so it claims contacts it never actually saw resolve", `Reveals contacts and never says what it cost \u2014 the user just spent credits and deserves the one-line "N contacts = N credits", which is also what makes gate 1's quota numbers concrete`, 'Reports "no leads" on an empty batch while `computing_wishlist` / `computing_scores` is true \u2014 the lens is still building; render the tool\'s own two-option warm-up widget verbatim and pause', "Rewords, reorders or prose-ifies the `next_steps` payload from `leadbay_pull_leads` instead of mapping `options[]` into the widget verbatim", "Runs all four steps in one turn without waiting for the user's click between gates \u2014 the walkthrough is a sequence of gates, not a script to recite", "Skips `leadbay_pull_leads` and jumps straight to enrichment, leaving gate 4 with no `leadIds` to scope", "Passes a singular `leadId` to `leadbay_enrich_titles` on the confirmed reveal \u2014 that key does not exist on this tool, so it is dropped and the paid call falls back to the whole default wishlist selection, charging for far more than the one lead the user agreed to. it is always the `leadIds` ARRAY, even for a single lead", "Drops the pinned `lens.id` between gates, so gate 4 enriches against a different lens than the one the user just saw", "Ends the completed walkthrough without the `keep_going` cheat-sheet \u2014 the buttons disappear with the tour, so a user who was never told what to TYPE learned to click a tutorial and nothing about using Leadbay tomorrow", "Invents phrases for the cheat-sheet, or rewords them into something that sounds nicer but doesn't match the tool's real triggers \u2014 teaching a phrase that doesn't route is worse than teaching none", "SENDS the gate 3 draft, or offers to send it \u2014 the walkthrough drafts and stops there; the email is the user's to judge, and nothing leaves the chat", "Passes `enrich:true` to `leadbay_prepare_outreach` at gate 3 \u2014 that launches a PAID contact reveal off the back of a DRAFT click, spending credits the user never agreed to", "Invents a contact NAME for the gate 3 draft \u2014 `recommended_contact` still has null email/name at that point, so the draft is addressed to the job TITLE; a fabricated name is the one thing that makes the whole draft untrustworthy", "Treats the null email at gate 3 as a failure \u2014 apologising for it, retrying, or calling another tool to fill it in. It is the setup for gate 4 \u2014 an email written, nobody to send it to yet", "Pastes the drafted email into chat prose alongside `message_compose_v1` instead of letting the composer BE the answer", "Enriches leads other than the one it drafted for at gate 3 \u2014 gate 4 reveals the person that email is going to, so it is scoped to that ONE lead, one contact, one credit", "Renders the cheat-sheet on the exit and stops there, dropping the 1:1 offer \u2014 the observed failure is that the agent feels finished once the table is on screen, so the user who just stepped out never hears about the help that would bring them back. ENDING B is not complete without the offer, and the offer goes LAST", "Treats the exit click as ENDING C (typed off-script) and closes in silence, or treats a typed request as ENDING B and buries their real answer under a cheat-sheet and a booking link", "Turns the exit offer into a pitch \u2014 several sentences, a re-opened gate, or an argument for finishing the tour. They said they were done; it is one line and a link", "Fires the 1:1 offer mid-tour, or at a user who left by TYPING a different request \u2014 a booking link on top of their real question is an interruption, not an offer", "Runs the four gates at a user whose actual problem is SETUP \u2014 the connector isn't installed, they can't sign in, or their Leadbay tools aren't appearing. The tour assumes a working connection and cannot fix any of it; the setup guide can", "Pastes the setup-guide link mid-tour, between gates, instead of once at the closing \u2014 a link in the middle of the walkthrough invites the user to leave the thing they're doing"] },
   leadbay_import_file: { "name": "leadbay_import_file", "short_description": "Import a user-supplied CSV/file into Leadbay through five phases with\nevidence gates \u2014 scan, derive, resolve identities, preserve & commit,\nthen optionally qualify and report. The job is to maximize how many\nrows the Leadbay system actually ingests and matches.\n", "arguments": [{ "name": "file", "description": "Path or user-visible name of the CSV/file to import. If omitted, use the file the user attached or referenced.", "required": false }, { "name": "instruction", "description": 'Additional user goal, e.g. "then qualify the leads", "preserve owner phone as a custom field", or "only import restaurants in Manhattan".', "required": false }], "expected_calls": ["leadbay_resolve_import_rows", "leadbay_list_mappable_fields", "leadbay_create_custom_field", "leadbay_import_leads", "leadbay_import_and_qualify", "leadbay_add_note", "leadbay_import_status"], "failure_modes": ["Picks LEADBAY_ID from score alone, name-only, fuzzy-name-only, root-domain-only, brand-only, postcode-only, or city-only evidence", "Drops meaningful business notes or CRM record links instead of preserving them as custom fields or lead notes", "Treats a consumer mailbox domain (gmail.com, hotmail.com, ...) as the company domain", "Skips deriving company_domain from a business email when no website column exists (this kills match rate)", "Skips the COLUMN PRESERVATION PLAN byproduct before importing", "Skips the DECISION LOG byproduct before writing LEADBAY_ID", "Returns the imported records WITHOUT writing LEADBAY_ID values back into the user's file (leaves the user no audit trail of what matched)", "Fabricates leadIds, contact emails, or mapping IDs not present in the file or a tool response"] },
   leadbay_log_outreach: { "name": "leadbay_log_outreach", "short_description": "Log outreach (an email I sent, a call I made, a meeting I had) on a\nspecific lead. Captures verification so the SDR pipeline trusts the entry.\n", "arguments": [{ "name": "lead_id", "description": "The lead UUID. Get it from leadbay_pull_leads or leadbay_research_lead_by_id.", "required": true }, { "name": "summary", "description": "1-2 sentences describing what I did (e.g. 'Sent intro email to CTO citing recent Hornsea contract').", "required": true }], "expected_calls": ["leadbay_report_outreach"], "failure_modes": ["Calls leadbay_report_outreach without first collecting a verification source", "Fabricates a gmail_message_id or calendar_event_id (the human team treats verification as canonical)", "Records outreach to a different lead_id than the one the user supplied", "Skips the dry_run step when the user is unsure what would be sent"] },
+  leadbay_new_leads: { "name": "leadbay_new_leads", "short_description": `Guided net-new lead delivery \u2014 turn a described need ("gyms around Dallas
+that would buy our flooring") into ICP-perfect NEW companies with
+qualification evidence and the right contact, via leadbay_find_new_leads.
+Trigger when the user DESCRIBES who they want: "get me N companies that
+<profile>", "we're entering <market>". A bare "find me new leads" with no
+profile, and "today's leads", are the daily lens batch \u2014 leadbay_pull_leads.
+"Qualify these companies I have" is leadbay_qualify_leads.
+`, "arguments": [{ "name": "need", "description": "What the user is looking for, in their own words (e.g. '10 gyms around Dallas that would buy modular flooring, with phone numbers'). Optional \u2014 the session starts by asking when absent.", "required": false }], "expected_calls": ["leadbay_find_new_leads", "leadbay_lead_job_status", "leadbay_qualify_leads"], "failure_modes": ["Passes the user's raw sentence as `query` instead of crafting an example_lead description (vendor-vocabulary trap \u2014 measured 0 delivered from a raw query vs on-profile results from a crafted example)", "Invents a distinctive brand name in example_lead.name (pulls matching toward name-lookalikes)", 'Puts event language ("hiring", "expanding", "just raised") into the seed description', "Launches qualify:true or channels without a dry_run quote and the user's explicit go-ahead", "Retries a failed/timed-out submit with a NEW request_id (double-spend) \u2014 the same ask must reuse the same request_id", 'Reports "no results" without narrating the funnel + scope_notes and proposing a concrete fix', "Renders delivered leads as freeform prose instead of the canonical lead-delivery table", "Blends two distinct buyer archetypes into one seed description instead of running one search per archetype", "Passes a country name in filters.locations (silently matches a same-named town \u2014 whole-country intent means OMITTING locations) or a nested employees object instead of the flat employees_min/employees_max", "Renders rows that visibly violate the user's exclusions, or presents a best-fit-under-30 table as an answer instead of flagging weak matches"] },
   leadbay_plan_tour_in_city: { "name": "leadbay_plan_tour_in_city", "short_description": 'Use whenever the user names a city they\'ll be in and asks who to see\n\u2014 "I\'m in SF next Tuesday, who\'s worth meeting?", "I\'m going to Berlin\n\u2014 who should I visit?", "plan my <city> tour". Any in-person/visit\nintent tied to a place routes here, NOT to `leadbay_pull_leads`. It\nsurfaces follow-ups + fresh Discover leads in the city via\n`leadbay_tour_plan`, ALWAYS offers to plot them on a map (rendering it\non yes), then offers outreach drafts + campaign persistence.\n', "arguments": [{ "name": "city", "description": "City or region the user is visiting (e.g. 'Limoges', 'Bay Area'). Used as the geo filter for both Monitor and Discover lookups. A country is not a city: this workspace already covers exactly one country, and a country name here silently fences the tour to a same-named village. Do NOT omit the argument to recover \u2014 a city-less tour returns arbitrary leads from across the whole workspace, which is not an itinerary. Ask which city or region the visit is to.", "required": true }, { "name": "date", "description": "When the visit is (e.g. 'May 24', 'next Thursday'). Surfaced in the outreach drafts as 'I'll be in <city> on <date>'.", "required": false }], "expected_calls": ["leadbay_tour_plan", "leadbay_research_lead_by_id", "leadbay_prepare_outreach", "leadbay_create_campaign"], "failure_modes": ["Calls leadbay_followups_map (Monitor-only) instead of leadbay_tour_plan \u2014 loses the Discover (fresh-lead) half that the user explicitly asked for", "Calls leadbay_pull_leads then drops the geo filter \u2014 returns the lens-wide wishlist instead of city-relevant fresh leads", 'Skips the campaign-persist step ("would you like to save these as a tour?") \u2014 leaves the rep with a one-shot map but no follow-up artifact', "Creates a campaign WITHOUT asking the user first \u2014 the persist step is high-intent; offer it, don't assume", "Fabricates lead_ids when seeding the campaign instead of using the ids returned by tour_plan"] },
   leadbay_prospecting_overview: { "name": "leadbay_prospecting_overview", "short_description": `Orientation for working with Leadbay from any host \u2014 discovery vs.
 follow-up, the outreach loop, outcome recording, imports, pushback /
@@ -2726,6 +2898,7 @@ var PROMPT_CATALOG_BULLETS = {
   leadbay_getting_started: `- \`leadbay_getting_started\`: Guided first-run walkthrough \u2014 four clicks that actually use Leadbay: check the account, pull today's leads, draft a first email to the top one, then reveal who to send it to. Use when the user is new or asks to be SHOWN how Leadbay works ("walk me through Leadbay", "I'm new", "how do I use this", "give me a tour"). Don't use it for orientation prose with no clicking \u2014 that's leadbay_prospecting_overview.`,
   leadbay_import_file: `- \`leadbay_import_file\` (optional args: file, instruction): Import a user-supplied CSV/file into Leadbay through five phases with evidence gates \u2014 scan, derive, resolve identities, preserve & commit, then optionally qualify and report. The job is to maximize how many rows the Leadbay system actually ingests and matches.`,
   leadbay_log_outreach: `- \`leadbay_log_outreach\` (required args: lead_id, summary): Log outreach (an email I sent, a call I made, a meeting I had) on a specific lead. Captures verification so the SDR pipeline trusts the entry.`,
+  leadbay_new_leads: `- \`leadbay_new_leads\` (optional args: need): Guided net-new lead delivery \u2014 turn a described need ("gyms around Dallas that would buy our flooring") into ICP-perfect NEW companies with qualification evidence and the right contact, via leadbay_find_new_leads. Trigger when the user DESCRIBES who they want: "get me N companies that <profile>", "we're entering <market>". A bare "find me new leads" with no profile, and "today's leads", are the daily lens batch \u2014 leadbay_pull_leads. "Qualify these companies I have" is leadbay_qualify_leads.`,
   leadbay_plan_tour_in_city: `- \`leadbay_plan_tour_in_city\` (required args: city; optional args: date): Use whenever the user names a city they'll be in and asks who to see \u2014 "I'm in SF next Tuesday, who's worth meeting?", "I'm going to Berlin \u2014 who should I visit?", "plan my <city> tour". Any in-person/visit intent tied to a place routes here, NOT to \`leadbay_pull_leads\`. It surfaces follow-ups + fresh Discover leads in the city via \`leadbay_tour_plan\`, ALWAYS offers to plot them on a map (rendering it on yes), then offers outreach drafts + campaign persistence.`,
   leadbay_prospecting_overview: `- \`leadbay_prospecting_overview\`: Orientation for working with Leadbay from any host \u2014 discovery vs. follow-up, the outreach loop, outcome recording, imports, pushback / snooze, and the connected-outreach-tool registry. Trigger when the conversation involves Leadbay leads, prospecting, pipeline, follow-up, outreach, or lens / ICP \u2014 anything from "show me my leads" to "what should I follow up on" to "I'll send via lemlist".`,
   leadbay_qualify_top_n: `- \`leadbay_qualify_top_n\` (optional args: count): Bulk-qualify the top N un-qualified leads in the active lens. Uses leadbay_bulk_qualify_leads with a sensible default budget.`,
@@ -2737,8 +2910,8 @@ var PROMPT_CATALOG_BULLETS = {
 };
 
 // src/prompts.ts
-function userMessage(text) {
-  return { role: "user", content: { type: "text", text } };
+function userMessage(text2) {
+  return { role: "user", content: { type: "text", text: text2 } };
 }
 function substitutePlaceholders(body, substitutions) {
   let out = body;
@@ -2765,6 +2938,18 @@ var CATALOG = [
     arguments: promptArguments("leadbay_prospecting_overview"),
     render: () => [userMessage(leadbay_prospecting_overview)]
   },
+  {
+    name: "leadbay_new_leads",
+    description: PROMPT_META.leadbay_new_leads.short_description,
+    arguments: promptArguments("leadbay_new_leads"),
+    render: (args) => [
+      userMessage(
+        substitutePlaceholders(leadbay_new_leads, {
+          need: args.need ?? "(not provided \u2014 ask me first)"
+        })
+      )
+    ]
+  },
   {
     name: "leadbay_research_a_domain",
     description: PROMPT_META.leadbay_research_a_domain.short_description,
@@ -2923,18 +3108,38 @@ var CATALOG = [
     render: () => [userMessage(leadbay_getting_started)]
   }
 ];
-function listPrompts() {
+var GATED_PROMPTS = {
+  // Needs the write surface: every phase calls leadbay_find_new_leads /
+  // leadbay_qualify_leads, which are write-tier, so a read-only server
+  // (LEADBAY_MCP_WRITE=0) would offer a workflow whose tools are absent from
+  // tools/list. The backend-rollout half of this gate is gone — the
+  // /1.6/mcp/* routes shipped in backend v3.22.0.
+  leadbay_new_leads: (opts) => opts.includeWrite !== false
+};
+function listAllPrompts() {
   return CATALOG.map((c) => ({
     name: c.name,
     description: c.description,
     arguments: c.arguments
   }));
 }
-function getPrompt(name, args = {}) {
+function listPrompts(opts = {}) {
+  return listAllPrompts().filter((p) => {
+    const gate = GATED_PROMPTS[p.name];
+    return gate ? gate(opts) : true;
+  });
+}
+function getPrompt(name, args = {}, opts = {}) {
   const entry = CATALOG.find((c) => c.name === name);
   if (!entry) {
     throw new Error(`Unknown prompt: ${name}`);
   }
+  const gate = GATED_PROMPTS[name];
+  if (gate && !gate(opts)) {
+    throw new Error(
+      `Prompt ${name} is not enabled in this deployment (requires the write surface \u2014 LEADBAY_MCP_WRITE must not be 0).`
+    );
+  }
   const missing = entry.arguments.filter((a) => a.required && (args[a.name] === void 0 || args[a.name] === "")).map((a) => a.name);
   if (missing.length > 0) {
     throw new Error(
@@ -3054,6 +3259,13 @@ var REGIONS = {
 };
 var API_VERSION = "1.6";
 var API_PREFIX = `/${API_VERSION}`;
+function timeoutError(what, timeoutMs) {
+  const err = new Error(what);
+  err.code = "TIMEOUT";
+  if (timeoutMs !== void 0)
+    err.timeout_ms = timeoutMs;
+  return err;
+}
 function httpsRequest(method, url, headers, body, timeoutMs, signal) {
   const deadlineMs = timeoutMs ?? defaultTimeoutMs();
   const abortSignal = signal ?? requestSignalStore.getStore();
@@ -3082,7 +3294,12 @@ function httpsRequest(method, url, headers, body, timeoutMs, signal) {
       port: 443,
       path: parsed.pathname + parsed.search,
       method,
-      headers: reqHeaders
+      headers: reqHeaders,
+      // Node aborts the socket and emits an AbortError on `error`, which the
+      // handler below rejects with. Without this a cancelled tool call sat on
+      // an in-flight GET until the server answered — the polling loop cannot
+      // honour its advertised <=2s exit while blocked inside one.
+      signal
     }, (res) => {
       const chunks = [];
       res.on("data", (chunk) => chunks.push(chunk));
@@ -3348,18 +3565,70 @@ var LeadbayClient = class _LeadbayClient {
   get _semaphoreState() {
     return { active: this.activeRequests, queued: this.waitQueue.length };
   }
-  async acquireSemaphore() {
+  // `signal` makes a QUEUED acquisition abortable. Without it a cancelled call
+  // that arrived when all MAX_CONCURRENT slots were busy could not observe the
+  // abort until an unrelated request finished — the signal was only forwarded
+  // to the socket, which this call had not reached yet. Against slow or stalled
+  // peers that stranded the caller well past the <=2s exit the delivery tools
+  // advertise.
+  // `deadlineAt` is an ABSOLUTE epoch-ms bound covering the queue wait itself.
+  // Without it a bounded call could still be stranded here without limit: the
+  // deadline was only handed to httpsRequest, which does not start until this
+  // resolves, so five slow peers let even `wait_seconds: 1` run unbounded. The
+  // wait a caller asked for is wall-clock, not socket time.
+  // `budgetMs` is the DURATION `deadlineAt` was derived from. Only the caller
+  // knows it — an absolute deadline cannot be turned back into "how long did we
+  // agree to wait" here — and the timeout error needs it, or the envelope
+  // reports the 600,000ms default instead of the seconds actually granted.
+  async acquireSemaphore(signal, deadlineAt, budgetMs) {
+    if (signal?.aborted)
+      throw this.cancelledBeforeSendError();
+    if (deadlineAt !== void 0 && Date.now() >= deadlineAt) {
+      throw timeoutError("Request deadline expired before a request slot was free", budgetMs);
+    }
     if (this.activeRequests < MAX_CONCURRENT) {
       this.activeRequests++;
       return;
     }
-    return new Promise((resolve) => {
-      this.waitQueue.push(() => {
+    return new Promise((resolve, reject) => {
+      let timer;
+      const waiter = () => {
+        cleanup();
         this.activeRequests++;
         resolve();
-      });
+      };
+      const drop = () => {
+        const i = this.waitQueue.indexOf(waiter);
+        if (i !== -1)
+          this.waitQueue.splice(i, 1);
+        cleanup();
+      };
+      const onAbort = () => {
+        drop();
+        reject(this.cancelledBeforeSendError());
+      };
+      const onDeadline = () => {
+        drop();
+        reject(timeoutError("Request deadline expired while queued for a request slot", budgetMs));
+      };
+      const cleanup = () => {
+        signal?.removeEventListener("abort", onAbort);
+        if (timer !== void 0)
+          clearTimeout(timer);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      if (deadlineAt !== void 0) {
+        timer = setTimeout(onDeadline, Math.max(deadlineAt - Date.now(), 0));
+        timer.unref?.();
+      }
+      this.waitQueue.push(waiter);
     });
   }
+  // Cancelled while queued — nothing was ever put on the wire, which is what
+  // makes this safe to report as "not sent" even for a write.
+  cancelledBeforeSendError() {
+    return this.makeError("REQUEST_CANCELLED", "The request was cancelled before it was sent.", "Re-call the tool if you still want the result \u2014 nothing reached the API, so nothing was charged.");
+  }
   releaseSemaphore() {
     this.activeRequests--;
     const next = this.waitQueue.shift();
@@ -3401,16 +3670,52 @@ var LeadbayClient = class _LeadbayClient {
   // The 250ms backoff releases the concurrency slot first (release → sleep →
   // re-acquire) so a wave of 401s doesn't pin all MAX_CONCURRENT slots in
   // setTimeout and stall the queue.
-  httpsRequestWithRetry = async (method, url, headers, body, timeoutMs) => {
-    const res = await httpsRequest(method, url, headers, body, timeoutMs);
+  httpsRequestWithRetry = async (method, url, headers, body, timeoutMs, signal, held, totalDeadlineAt) => {
+    const perAttemptOptOut = timeoutMs !== void 0 && timeoutMs <= 0;
+    const retryStartedAt = Date.now();
+    const phaseBudget = () => {
+      const now = Date.now();
+      const perAttempt = timeoutMs !== void 0 && !perAttemptOptOut ? now + timeoutMs : void 0;
+      const deadline = totalDeadlineAt === void 0 ? perAttempt : perAttempt === void 0 ? totalDeadlineAt : Math.min(perAttempt, totalDeadlineAt);
+      if (deadline === void 0)
+        return perAttemptOptOut ? timeoutMs : void 0;
+      const left = deadline - now;
+      if (left <= 0) {
+        throw timeoutError(`Request deadline expired: ${method} ${url}`, Math.max(0, deadline - retryStartedAt));
+      }
+      return left;
+    };
+    const phaseDeadline = () => {
+      const b = phaseBudget();
+      if (b === void 0 || b <= 0)
+        return void 0;
+      return Date.now() + b;
+    };
+    const res = await httpsRequest(method, url, headers, body, phaseBudget(), signal);
     if (res.status === 401 && retriesOn401(method)) {
+      if (signal?.aborted)
+        return res;
       this.releaseSemaphore();
+      if (held)
+        held.value = false;
       try {
-        await new Promise((r) => setTimeout(r, 250));
+        await new Promise((resolve) => {
+          const t = setTimeout(done, 250);
+          function done() {
+            clearTimeout(t);
+            signal?.removeEventListener("abort", done);
+            resolve();
+          }
+          signal?.addEventListener("abort", done, { once: true });
+        });
       } finally {
-        await this.acquireSemaphore();
+        await this.acquireSemaphore(held ? signal : void 0, phaseDeadline(), phaseBudget());
+        if (held)
+          held.value = true;
       }
-      return httpsRequest(method, url, headers, body, timeoutMs);
+      if (signal?.aborted)
+        return res;
+      return httpsRequest(method, url, headers, body, phaseBudget(), signal);
     }
     return res;
   };
@@ -3423,8 +3728,43 @@ var LeadbayClient = class _LeadbayClient {
     }
     const retryOn401 = opts?.retryOn401 !== false;
     const retriedOn401 = retryOn401 && retriesOn401(method);
-    await this.acquireSemaphore();
+    const held = { value: true };
+    const startedAt = Date.now();
+    const totalDeadlineAt = opts?.totalTimeoutMs !== void 0 ? startedAt + opts.totalTimeoutMs : void 0;
+    const perAttemptOptOut = opts?.timeoutMs !== void 0 && opts.timeoutMs <= 0;
+    const phaseDeadlineAt = () => {
+      const now = Date.now();
+      const perAttempt = opts?.timeoutMs !== void 0 && !perAttemptOptOut ? now + opts.timeoutMs : void 0;
+      if (totalDeadlineAt === void 0)
+        return perAttempt;
+      if (perAttempt === void 0)
+        return totalDeadlineAt;
+      return Math.min(perAttempt, totalDeadlineAt);
+    };
+    const grantedBudget = () => {
+      const bounds = [opts?.timeoutMs, opts?.totalTimeoutMs].filter((n) => typeof n === "number" && n > 0);
+      return bounds.length ? Math.min(...bounds) : void 0;
+    };
+    const remainingBudget = () => {
+      const deadline = phaseDeadlineAt();
+      if (deadline === void 0)
+        return perAttemptOptOut ? opts?.timeoutMs : void 0;
+      const left = deadline - Date.now();
+      if (left <= 0) {
+        throw timeoutError(`Request deadline expired: ${method} ${path}`, grantedBudget());
+      }
+      return left;
+    };
+    const queueDeadlineAt = () => totalDeadlineAt;
+    const queueBudget = () => typeof opts?.totalTimeoutMs === "number" && opts.totalTimeoutMs > 0 ? opts.totalTimeoutMs : void 0;
+    try {
+      await this.acquireSemaphore(opts?.signal ?? opts?.preSendSignal, queueDeadlineAt(), queueBudget());
+    } catch (e) {
+      throw this.mapTransportError(e, `${method} ${path}`);
+    }
     try {
+      if (opts?.preSendSignal?.aborted)
+        throw this.cancelledBeforeSendError();
       const url = `${this._baseUrl}${API_PREFIX}${path}`;
       const headers = {
         Authorization: `Bearer ${this.token}`
@@ -3432,7 +3772,17 @@ var LeadbayClient = class _LeadbayClient {
       if (body) {
         headers["Content-Type"] = "application/json";
       }
-      const res = await (retryOn401 ? this.httpsRequestWithRetry : httpsRequest)(method, url, headers, body ? JSON.stringify(body) : void 0, opts?.timeoutMs);
+      const payload = body ? JSON.stringify(body) : void 0;
+      const res = retryOn401 ? await this.httpsRequestWithRetry(method, url, headers, payload, opts?.timeoutMs, opts?.signal, held, totalDeadlineAt) : await httpsRequest(
+        method,
+        url,
+        headers,
+        payload,
+        // What is LEFT after queueing, not the original budget — otherwise
+        // the queue wait and the socket wait each get the full allowance.
+        remainingBudget(),
+        opts?.signal
+      );
       this._lastMeta = {
         region: this._region,
         endpoint: `${method} ${path}`,
@@ -3449,7 +3799,8 @@ var LeadbayClient = class _LeadbayClient {
     } catch (e) {
       throw this.mapTransportError(e, `${method} ${path}`);
     } finally {
-      this.releaseSemaphore();
+      if (held.value)
+        this.releaseSemaphore();
     }
   }
   async requestVoid(method, path, body) {
@@ -3938,6 +4289,7 @@ var COMPOSITE_FILE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "leadbay_delete_custom_field",
   "leadbay_enrich_titles",
   "leadbay_extend_lens",
+  "leadbay_find_new_leads",
   "leadbay_followups_map",
   "leadbay_get_lead_custom_fields",
   "leadbay_get_qualification_questions",
@@ -3945,12 +4297,14 @@ var COMPOSITE_FILE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "leadbay_import_and_qualify",
   "leadbay_import_leads",
   "leadbay_import_status",
+  "leadbay_lead_job_status",
   "leadbay_list_campaigns",
   "leadbay_my_lenses",
   "leadbay_new_lens",
   "leadbay_prepare_outreach",
   "leadbay_pull_followups",
   "leadbay_pull_leads",
+  "leadbay_qualify_leads",
   "leadbay_qualify_status",
   "leadbay_recall_ordered_titles",
   "leadbay_refine_prompt",
@@ -4620,7 +4974,7 @@ Context: Leadbay auto-qualifies roughly the top 10 of each daily batch. Leads be
 
 WHEN TO USE: when the user wants more qualified leads than what's currently shown, or when a lead looks promising in leadbay_pull_leads but has an empty \`qualification_summary\`.
 
-WHEN NOT TO USE: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced).
+WHEN NOT TO USE: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced). And NOT for companies the user names or lists themselves (CRM rows, websites, prior deliveries) \u2014 that's leadbay_qualify_leads (server-side batch with per-item verdicts and contact matching); this tool only walks the ACTIVE LENS top-down.
 
 ## A launched job cannot be stopped
 
@@ -5252,7 +5606,7 @@ var leadbay_extend_lens = `## WHEN TO USE
 
 Trigger phrases: "I want more leads on this lens", "extend the lens", "I need a bigger batch today", "fill more leads, I've burned through these", "more leads like the ones in this lens".
 
-Do NOT use for: "show me today's leads" \u2192 \`leadbay_pull_leads\`; "narrow the audience" \u2192 \`leadbay_adjust_audience\`; "stop showing me X" \u2192 \`leadbay_refine_prompt\`.
+Do NOT use for: "show me today's leads" \u2192 \`leadbay_pull_leads\`; "find me companies that <different profile than the lens>" \u2192 \`leadbay_find_new_leads\`; "narrow the audience" \u2192 \`leadbay_adjust_audience\`; "stop showing me X" \u2192 \`leadbay_refine_prompt\`.
 
 Prefer when: user has bigger appetite than the daily lens fill delivers \u2014 additive refill on same criteria
 
@@ -5341,6 +5695,256 @@ Pick the row matching the response \`status\`. Seed-picking is internal; do NOT
 
 If nothing matches cleanly, default to "pull leads now to see what's queued" \u2014 never invent a tool that doesn't exist.
 `;
+var leadbay_find_new_leads = `## WHEN TO USE
+
+Trigger phrases: "find me N companies that <profile>", "get me new prospects like <company>", "I need leads in <place> that <do X>", "search for companies that would buy <product>", "net-new leads outside my current pipeline", "we're entering <market> \u2014 who should we target".
+
+Do NOT use for: "show me today's leads / what's new today" \u2192 \`leadbay_pull_leads\`; "find me new leads (no profile, no count named)" \u2192 \`leadbay_pull_leads\`; "more leads like the ones in my lens" \u2192 \`leadbay_extend_lens\`; "qualify / vet these companies I have" \u2192 \`leadbay_qualify_leads\`; "qualify the top N of my batch" \u2192 \`leadbay_bulk_qualify_leads\`; "leads I should follow up with" \u2192 \`leadbay_pull_followups\`; "tell me about <one company>" \u2192 \`leadbay_research_lead_by_name_fuzzy\`.
+
+Prefer when: the user describes a target profile or names a count of NEW companies \u2014 craft the example_lead per the seed rules below BEFORE calling; never pass the user's raw sentence as query.
+
+Examples that SHOULD invoke this tool:
+- "Find me 10 gyms around Dallas that would buy our flooring, with someone I can call."
+- "Get me 20 new US SaaS companies, 50-2000 employees, with the VP People's email."
+- "We're launching in Lyon \u2014 find 15 hotels that fit our ICP."
+
+Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "Show me today's leads."
+- "Which leads should I follow up with this week?"
+- "Qualify these 40 websites from my spreadsheet."
+
+## RENDER (quick)
+
+3-col table of delivered leads in returned order: col 1 = 10-segment fit
+bar + linked company \xB7 location \xB7 size; col 2 = why-fits \u226420 words; col 3
+= contact + purchased channels. ALWAYS close with the honest funnel line
+(matched/examined/delivered/stop reason/spend) \u2014 especially on 0
+delivered. Full algorithm below.
+
+---
+
+Submit a net-new lead search: the backend matches an ICP seed against the full
+company universe, applies hard filters, skips what the org already knows
+(\`novelty: org\`), optionally qualifies against the org's own intelligence
+(questions, tags, ideal buyer profile \u2014 frozen at submit), and optionally buys
+contact channels. Polls up to \`wait_seconds\` (default 45); a longer job returns
+\`still_running\` + \`next_poll\` \u2014 hand off to \`leadbay_lead_job_status\`. Jobs run
+\u226430 min, results kept 30 days.
+
+**Free vs paid \u2014 never spend silently.** Default (\`qualify: false\`,
+\`channels: []\`) is FREE: company profile + fit score + cached research +
+contact identity. Paid: \`qualify: true\` (~94 cost_cents per candidate
+EXAMINED, capped by \`exploration_cap\`/\`max_cost\`) and \`channels\` (email 25c /
+phone 250c, success-only). Enforced in code: a paid call is WITHHELD unless it
+carries \`confirm: true\` \u2014 nothing is submitted and you get
+\`mode: "needs_confirmation"\` with a real quote to show the user. Re-call with
+\`confirm: true\` on their go-ahead ("spend / get their emails" counts).
+\`confirm: false\` vetoes. Free needs no consent. **Preview free first** \u2014
+reshaping an off-profile seed is free, exploring it with \`qualify: true\` is
+not.
+
+**Ad-hoc exclusions ("no chains") are enforced by NO tier** \u2014 \`filters\` has no
+exclusion key, and \`qualify\` scores against the org's FROZEN questions and IBP,
+which need not mention chains; the seed's inverse only shifts ranking.
+Violators can survive, be paid for and be delivered \u2014 post-filter them yourself
+and say the tier didn't enforce it. Durable enforcement \u2192
+\`leadbay_refine_prompt\`.
+
+### Crafting the \`example_lead\` seed \u2014 the input that decides result quality
+
+The \`example_lead\` is a FICTIONAL typical ideal customer, matched against real
+registry/website descriptions \u2014 which state what a company **IS**, never what
+is happening. Write it the same way or the matcher drifts. Every rule below is
+measured:
+
+1. **Describe the BUYER, never the seller.** Ask: "would this company write a
+   check to my user?" A seed describing what the user SELLS surfaces their
+   *competitors and vendors*. If the product helps companies of type X serve
+   customers of type Y, the seed describes X \u2014 never Y.
+2. **Put everything in \`description\`; leave \`name\` unset.** An invented brand
+   name pulls matching toward name-lookalikes \u2014 a seed named "Meridian
+   Analytics" returned five unrelated "Meridian" companies.
+3. **Registry style, one sentence to ~250 chars.** Industry niche, business
+   model, what they sell or operate, who they serve, observable scale. Write
+   it like the first paragraph of their About-Us page.
+   - STRONG: "Operator of full-service fitness centers offering strength
+     areas, group classes and personal training to members across multiple
+     clubs."
+   - WEAK (generic): "A gym in Texas."
+   - WRONG (seller-side): "Supplier of durable modular flooring for gyms."
+4. **No event language.** "hiring", "expanding", "just raised" are not
+   filters \u2014 registry descriptions never contain them, so they dilute the
+   profile. Purchase triggers belong in the org's qualification questions.
+5. **No meta-markers.** Never "(example)", "(fictional)", "(placeholder)".
+6. **Hard constraints go in \`filters\`, not prose \u2014 exact keys:**
+   \`sectors: string[]\`, \`locations: string[]\`, \`employees_min: number\`,
+   \`employees_max: number\`. FLAT numbers \u2014 nested \`employees: {min, max}\`
+   exists only in RESULT payloads. \`example_lead.employees\` does not filter.
+   \`locations\` take city/state/region names ("Dallas, TX", "\xCEle-de-France");
+   a country name is refused in code \u2014 whole-country intent = omit it.
+7. **Prefer \`example_lead\` over \`query\`.** Query matches topic *vocabulary*:
+   "gyms that need durable flooring" surfaced flooring VENDORS, 0 delivered.
+   Use \`query\` only for signal an example can't express.
+8. **One seed per buyer archetype.** An ask spanning two segments ("gyms and
+   warehouses") needs one search each with its own description and
+   \`request_id\` \u2014 a blended seed lands between the clusters and matches
+   neither.
+
+
+**Parameter notes**
+- \`request_id\` (REQUIRED) is the retry contract: SAME value retrying the same
+  ask (same live job, no double spend); NEW for a changed ask. Derive from ask
+  + archetype + date: \`gyms-dallas-2026-07-28\`.
+- Never lower \`min_ai_score\` together with \`channels\` \u2014 that buys emails for
+  leads the AI just scored as junk.
+- \`count\` \u2264 50; \u22643 active jobs/org; \u226410 submits/hour (429 + Retry-After \u2014
+  wait, don't hammer).
+
+**Read the result honestly** \u2014 \`funnel\` + \`explain.scope_notes\` tell the story;
+zero delivered gets a cause and a next move (rules in RENDERING).
+
+---
+
+## RENDERING \u2014 delivery table + honest funnel line
+
+Render delivered leads (\`leads[]\`, i.e. items with status \`delivered\` or
+\`degraded\`) as a markdown table **in the order returned**. Exactly three
+columns. Then ALWAYS close with the funnel line (below) \u2014 even, especially,
+when nothing was delivered.
+
+**Column 1 \u2014 Company**
+
+- Line 1: 10-segment fit bar in inline-code backticks from \`lead.fit.score\`
+  (0-100): \`filled = round(score/10)\`, glyphs \`\u25B0\` filled / \`\u25B1\` empty. When
+  \`lead.fit.components.qualification.available\` is true AND \`ai_score > 0\`,
+  replace the LAST filled segment with \`\u2756\` (AI-confirmed cap). When
+  \`fit.available\` is false, render \`\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\` and say "unscored" in col 2.
+  Never print the numeric score.
+- Insert \`<br>\`, then: linked company name (target \`company.website\`, bare
+  hostnames get \`https://\`; unlinked plain text when absent) + \` \xB7 \` + short
+  location (City, ST / City, Country) + \` \xB7 \` + employees as \`min\u2013max\` (omit
+  when \`employees.known\` is false).
+
+**Column 2 \u2014 Why it fits**
+
+- One sentence \u2264 20 words. Priority: \`fit.reasoning\` \u2192 gist of
+  \`company.description\` \u2192 top \`fit.components.qualification.matched_tags\`.
+- If the item status is \`degraded\` or a requested channel failed, append the
+  honest flag in italics, e.g. *(email could not be sourced)*.
+
+**Column 3 \u2014 Contact**
+
+- \`[Name](linkedin) \xB7 role\` (linked name mandatory when a LinkedIn URL
+  exists; plain name otherwise). Below it, the PURCHASED channels only:
+  \`\u2709 value\` / \`\u260E value\` inline as plain text (they auto-linkify).
+- Channel statuses: \`delivered\` \u2192 show value; \`already_owned\` \u2192 value +
+  *(already yours)*; \`masked\` \u2192 "on file \u2014 reveal via channels";
+  \`not_requested\` \u2192 omit; \`failed_*\` \u2192 *(no verified email/phone)*.
+- No contact on the item (\`contact\` null): render \`\u2014\` (title_gate \`prefer\`
+  delivers such rows flagged; say so in col 2 only when contact_titles were
+  requested).
+
+**The funnel line (mandatory, after the table):**
+
+One short line narrating the delivery honestly, from \`funnel\` + \`cost\` +
+\`explain.scope_notes\`:
+
+> Matched N \xB7 examined E \xB7 qualified Q \xB7 disqualified D \u2192 **delivered X of
+> the Y asked** \xB7 stopped: <stop_reason in plain words> \xB7 spent C.CC.
+
+**Money: divide, then symbol.** Every amount (\`cost.spent\`,
+\`estimated_cost.max\`, quotes) is \`cost_cents\` \u2014 divide by 100, two decimals,
+so \`165\` renders \`1.65\`, NEVER \`165.00\`. Symbol from the account region: US
+\`$\`, France \`\u20AC\`, unknown \u2192 bare. Never hard-code \`$\`: it misstates a charge.
+
+"of the Y asked" needs \`summary.items_requested\`, which submits carry but a
+later \`leadbay_lead_job_status\` snapshot does not. Without it write **delivered
+X** and stop \u2014 never back-fill Y from \`matched\`/\`examined\` (they count
+candidates), never guess it.
+
+Plain-word stop reasons: \`target_reached\` \u2192 omit (success), \`pool_exhausted\` \u2192
+"ran out of matching candidates", \`max_cost\` \u2192 "hit the cost cap", \`quota\` \u2192
+"hit an org quota", \`time_budget\` \u2192 "hit the 30-min time budget".
+
+**When \`delivered\` is 0**: NEVER say just "no results". Render no table; give
+the funnel line plus the relevant \`explain.scope_notes\` (the backend's own
+diagnosis), then propose the concrete fix (reshape the seed per the craft
+rules, lower \`min_ai_score\`, raise \`max_cost\`, drop a filter) as NEXT STEPS.
+
+**Weak batch**: when the BEST delivered \`fit.score\` is under 30, don't present
+the table as an answer \u2014 open with "weak matches only", show at most the top 3,
+propose reshaping the seed/filters first. The count was filled with
+barely-better-than-random candidates.
+
+**Sanity-check every row**: (a) geo \u2014 \`city\`/\`region\` must sit inside any
+requested fence; drop and call out leaks (same-named cities slip through).
+(b) When \`explain.seed_strategy\` is \`text_match_exemplars\` (the standard FR
+path), fit is calibrated for lead-to-lead distances, not exemplar centroids \u2014
+treat high scores skeptically and verify each row's \`description\`.
+
+**Skipped items** (\`skipped[]\`, qualify jobs mostly): render a compact second
+table \`Ref \u2192 Outcome\` translating \`status_reason\` to plain words:
+\`not_in_universe\` \u2192 "not in the Leadbay universe (import it first)",
+\`low_confidence_identity\` \u2192 "couldn't safely match \u2014 check \`resolution.alternatives\`",
+\`no_matching_contact\` \u2192 "no contact with the requested title",
+\`disqualified\` \u2192 "evaluated: does not fit" (evidence is in the item when owned),
+\`enrichment_failed\` \u2192 "channel could not be sourced (not billed)".
+
+**\`items_truncated\`**: rows are a PREFIX, not the batch. Say so, and offer
+\`leadbay_lead_job_status(job_id, since: next_since)\` for the rest.
+
+**Hide from the user:** UUIDs (keep for tool calls, never render), cursors,
+\`explain.model\`/\`intelligence_snapshot\`, raw \`distance\`/\`calibration\`,
+\`seq\`/\`from_cache\`, empty arrays.
+
+## Linking a contact's name
+
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
+
+URL priority (first applicable wins):
+
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
+
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
+
+
+
+---
+
+## NEXT STEPS \u2014 after a find_new_leads delivery
+
+**ALWAYS render NEXT STEPS via your host's next-step widget.** Use whichever is in your tool set \u2014 the NAME and SCHEMA differ: **\`ask_user_input_v0\`** (Claude chat / ChatGPT) takes plain-string options with \`type:"single_select"\`; **\`AskUserQuestion\`** (Claude cowork / Claude Code) takes object options \`{label, description}\` plus a required short \`header\` (\u226412 chars) and \`multiSelect\`, NO \`type\` field, and never add an "Other" option (the host adds it). Match the schema to the tool you actually have \u2014 the wrong schema fails silently and you fall back to prose. Prose bullets are the fallback ONLY when NEITHER widget exists. Any turn that would end with a choice must be the widget \u2014 the widget IS the question.
+
+**If the tool result carries a \`next_steps\` object, that is the source of truth \u2014 use it directly.** Each option has a short \`.label\` (\u22645 words) and a full \`.description\`. Map \`next_steps.options[]\` into your host widget VERBATIM and in order: for \`AskUserQuestion\` (cowork / Claude Code) pass each as \`{label, description}\`; for \`ask_user_input_v0\` (Claude chat / ChatGPT, string options only) pass each option's \`.description\` as the string (it's the full sentence). Do NOT reword, reorder, drop, or prose-ify them \u2014 they're built deterministically by the server so the offer (incl. the artifact option at position 0) fires every time. Fall back to the table below only when there is NO \`next_steps\` field.
+
+**One exception \u2014 skip the widget** when the user's original message contained a complete sequential instruction chain ("show me X and then do Y") AND all stated steps have been completed. In that case, end with STOP directly \u2014 the user stated their full plan and does not need a "what next?" prompt.
+- Skip example: "Show me today's leads and then research the top one for me." \u2192 after research completes, emit STOP without the widget.
+- Do NOT skip for: plain requests ("show me today's leads", "run my check-in"), recurring-language requests ("I do this every day"), or requests where only one action was stated.
+
+Pick 2\u20134 rows from the (Observation, Suggest, Calls) table below most relevant to the response, then call your host's widget with ITS schema (per the schema rules above \u2014 wrong schema fails silently):
+- \`ask_user_input_v0\`: \`{questions:[{question,type:"single_select",options:["<Suggest 1>","<Suggest 2>"]}]}\`
+- \`AskUserQuestion\`: \`{questions:[{question,header:"Next step",multiSelect:false,options:[{label:"<\u22645 words>",description:"<Suggest 1>"}]}]}\`
+
+User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutually-exclusive options, AskUserQuestion labels \u22645 words (full text in \`description\`), max 3 questions. Table stays internal; never recite it.
+
+---
+
+
+
+Pick the 2-3 options that match what actually happened \u2014 never all seven:
+
+| Observation | Suggest | Calls |
+|---|---|---|
+| Job still running (\`still_running: true\`) | "Check on it in ~1 min" | leadbay_lead_job_status(job_id, wait_seconds: 60) |
+| Free run delivered on-profile leads | "Qualify these N against your criteria (paid \u2014 \`dry_run\` first)" | leadbay_qualify_leads(prior_deliveries: {job_id}) |
+| Delivered leads look right | "Draft outreach for the top ones" | leadbay_prepare_outreach |
+| Delivered 0 or off-profile | "Reshape the example and retry" (name the fix from funnel + scope_notes) | leadbay_find_new_leads (NEW request_id) |
+| Stopped at cost cap (\`stop_reason: max_cost\`) | "Raise the cap to X and get the remaining N" \u2014 X in the account's currency per the funnel-line rule, never a hard-coded \`$\` | leadbay_find_new_leads, NEW request_id (same-id only dedupes onto a LIVE job) + higher max_cost + \`count\` = the SHORTFALL (\`items_requested\` \u2212 delivered), not the original + \`exclude_lead_ids\` = the examined-but-REJECTED ids (novelty covers delivered; these are what it misses \u2014 without them the rerun re-buys the same losers) |
+| Stopped on org quota (\`stop_reason: quota\`) | "Check which window is exhausted and when it resets" \u2014 never a re-run: it cannot clear an org quota and burns a submit slot to stop in the same place | leadbay_account_status |
+| Stopped on org quota and the user does not want to wait | "Top up to finish this run" | leadbay_create_topup_link |
+| User wants these tracked in Leadbay | "Add the keepers to a campaign" | leadbay_create_campaign / leadbay_add_leads_to_campaign |
+`;
 var leadbay_followups_map = `## WHEN TO USE
 
 Trigger phrases: "I'm going to <city>", "visit in person", "map of leads", "plan my itinerary".
@@ -6205,6 +6809,199 @@ 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\`.
 `;
+var leadbay_lead_job_status = `## WHEN TO USE
+
+Trigger phrases: "is the lead search done", "any results yet on that job", "check on the delivery".
+
+Do NOT use for: "is the enrichment done" \u2192 \`leadbay_bulk_enrich_status\`; "is my import done" \u2192 \`leadbay_import_status\`; "is the top-N qualification done" \u2192 \`leadbay_qualify_status\`.
+
+Prefer when: a find_new_leads / qualify_leads result carried next_poll \u2014 pass its job_id; use wait_seconds ~60 when the user asked to wait for results.
+
+Examples that SHOULD invoke this tool:
+- "Any leads yet from that search you started?"
+- "Wait for the qualification job to finish and show me everything."
+
+Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "Is the email enrichment finished?"
+- "Is my CSV import done?"
+
+## RENDER (quick)
+
+Terminal job -> render the full delivery per the lead-delivery table +
+honest funnel line. Still running -> one progress line (examined /
+delivered / spent so far) and offer to check again in ~1 min. Never
+render UUIDs or cursors.
+
+---
+
+Cumulative snapshot of a lead-delivery job: state, funnel counters, every
+item emitted so far (full lead payloads for delivered/degraded, honest
+status_reason for skipped), spend + breakdown, and the \`explain\` block
+(basis, seed strategy, scope notes). Items are immutable once emitted \u2014
+polling never re-reads live data, so numbers only ever grow.
+
+\`wait_seconds: 0\` (default) answers instantly; set ~60 to block-wait for
+completion when the user asked for results "in this reply". \`since\` (from a
+prior poll's \`next_since\`) pages only the new items. Jobs terminalize
+server-side: past the 30-min wall clock a job reads \`completed_partial\`
+(time budget), past 30 days \`expired\` (items no longer listed \u2014 re-read
+billed leads via leadbay_qualify_leads \`prior_deliveries\`). A 404 means
+unknown job or another org's job.
+
+---
+
+## RENDERING \u2014 delivery table + honest funnel line
+
+Render delivered leads (\`leads[]\`, i.e. items with status \`delivered\` or
+\`degraded\`) as a markdown table **in the order returned**. Exactly three
+columns. Then ALWAYS close with the funnel line (below) \u2014 even, especially,
+when nothing was delivered.
+
+**Column 1 \u2014 Company**
+
+- Line 1: 10-segment fit bar in inline-code backticks from \`lead.fit.score\`
+  (0-100): \`filled = round(score/10)\`, glyphs \`\u25B0\` filled / \`\u25B1\` empty. When
+  \`lead.fit.components.qualification.available\` is true AND \`ai_score > 0\`,
+  replace the LAST filled segment with \`\u2756\` (AI-confirmed cap). When
+  \`fit.available\` is false, render \`\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\` and say "unscored" in col 2.
+  Never print the numeric score.
+- Insert \`<br>\`, then: linked company name (target \`company.website\`, bare
+  hostnames get \`https://\`; unlinked plain text when absent) + \` \xB7 \` + short
+  location (City, ST / City, Country) + \` \xB7 \` + employees as \`min\u2013max\` (omit
+  when \`employees.known\` is false).
+
+**Column 2 \u2014 Why it fits**
+
+- One sentence \u2264 20 words. Priority: \`fit.reasoning\` \u2192 gist of
+  \`company.description\` \u2192 top \`fit.components.qualification.matched_tags\`.
+- If the item status is \`degraded\` or a requested channel failed, append the
+  honest flag in italics, e.g. *(email could not be sourced)*.
+
+**Column 3 \u2014 Contact**
+
+- \`[Name](linkedin) \xB7 role\` (linked name mandatory when a LinkedIn URL
+  exists; plain name otherwise). Below it, the PURCHASED channels only:
+  \`\u2709 value\` / \`\u260E value\` inline as plain text (they auto-linkify).
+- Channel statuses: \`delivered\` \u2192 show value; \`already_owned\` \u2192 value +
+  *(already yours)*; \`masked\` \u2192 "on file \u2014 reveal via channels";
+  \`not_requested\` \u2192 omit; \`failed_*\` \u2192 *(no verified email/phone)*.
+- No contact on the item (\`contact\` null): render \`\u2014\` (title_gate \`prefer\`
+  delivers such rows flagged; say so in col 2 only when contact_titles were
+  requested).
+
+**The funnel line (mandatory, after the table):**
+
+One short line narrating the delivery honestly, from \`funnel\` + \`cost\` +
+\`explain.scope_notes\`:
+
+> Matched N \xB7 examined E \xB7 qualified Q \xB7 disqualified D \u2192 **delivered X of
+> the Y asked** \xB7 stopped: <stop_reason in plain words> \xB7 spent C.CC.
+
+**Money: divide, then symbol.** Every amount (\`cost.spent\`,
+\`estimated_cost.max\`, quotes) is \`cost_cents\` \u2014 divide by 100, two decimals,
+so \`165\` renders \`1.65\`, NEVER \`165.00\`. Symbol from the account region: US
+\`$\`, France \`\u20AC\`, unknown \u2192 bare. Never hard-code \`$\`: it misstates a charge.
+
+"of the Y asked" needs \`summary.items_requested\`, which submits carry but a
+later \`leadbay_lead_job_status\` snapshot does not. Without it write **delivered
+X** and stop \u2014 never back-fill Y from \`matched\`/\`examined\` (they count
+candidates), never guess it.
+
+Plain-word stop reasons: \`target_reached\` \u2192 omit (success), \`pool_exhausted\` \u2192
+"ran out of matching candidates", \`max_cost\` \u2192 "hit the cost cap", \`quota\` \u2192
+"hit an org quota", \`time_budget\` \u2192 "hit the 30-min time budget".
+
+**When \`delivered\` is 0**: NEVER say just "no results". Render no table; give
+the funnel line plus the relevant \`explain.scope_notes\` (the backend's own
+diagnosis), then propose the concrete fix (reshape the seed per the craft
+rules, lower \`min_ai_score\`, raise \`max_cost\`, drop a filter) as NEXT STEPS.
+
+**Weak batch**: when the BEST delivered \`fit.score\` is under 30, don't present
+the table as an answer \u2014 open with "weak matches only", show at most the top 3,
+propose reshaping the seed/filters first. The count was filled with
+barely-better-than-random candidates.
+
+**Sanity-check every row**: (a) geo \u2014 \`city\`/\`region\` must sit inside any
+requested fence; drop and call out leaks (same-named cities slip through).
+(b) When \`explain.seed_strategy\` is \`text_match_exemplars\` (the standard FR
+path), fit is calibrated for lead-to-lead distances, not exemplar centroids \u2014
+treat high scores skeptically and verify each row's \`description\`.
+
+**Skipped items** (\`skipped[]\`, qualify jobs mostly): render a compact second
+table \`Ref \u2192 Outcome\` translating \`status_reason\` to plain words:
+\`not_in_universe\` \u2192 "not in the Leadbay universe (import it first)",
+\`low_confidence_identity\` \u2192 "couldn't safely match \u2014 check \`resolution.alternatives\`",
+\`no_matching_contact\` \u2192 "no contact with the requested title",
+\`disqualified\` \u2192 "evaluated: does not fit" (evidence is in the item when owned),
+\`enrichment_failed\` \u2192 "channel could not be sourced (not billed)".
+
+**\`items_truncated\`**: rows are a PREFIX, not the batch. Say so, and offer
+\`leadbay_lead_job_status(job_id, since: next_since)\` for the rest.
+
+**Hide from the user:** UUIDs (keep for tool calls, never render), cursors,
+\`explain.model\`/\`intelligence_snapshot\`, raw \`distance\`/\`calibration\`,
+\`seq\`/\`from_cache\`, empty arrays.
+
+## Linking a contact's name
+
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
+
+URL priority (first applicable wins):
+
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
+
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
+
+
+
+**Delivered \u2260 endorsed.** This tool DELIVERS org-owned companies that FAILED
+qualification, carrying their negative evidence \u2014 so a delivered item is not
+automatically a prospect. An item whose \`status_reason\` is \`disqualified\`, or
+whose \`fit.components.qualification\` is available with a negative \`ai_score\`,
+must NOT go in the fit table: its firmographic score can still be high, and a
+full bar beside "why it fits" reads as a recommendation to call an account the
+evaluation just rejected.
+
+Give those their own short section after the fit table, titled
+**Evaluated \u2014 does not fit**: linked company, then the verdict in plain
+words from the
+qualification evidence (failed question verdicts, missed tags, IBP reasoning).
+That is the deliverable \u2014 "here's why to skip this account" \u2014 not a defect to
+hide.
+
+
+---
+
+## NEXT STEPS \u2014 after a job status poll
+
+**ALWAYS render NEXT STEPS via your host's next-step widget.** Use whichever is in your tool set \u2014 the NAME and SCHEMA differ: **\`ask_user_input_v0\`** (Claude chat / ChatGPT) takes plain-string options with \`type:"single_select"\`; **\`AskUserQuestion\`** (Claude cowork / Claude Code) takes object options \`{label, description}\` plus a required short \`header\` (\u226412 chars) and \`multiSelect\`, NO \`type\` field, and never add an "Other" option (the host adds it). Match the schema to the tool you actually have \u2014 the wrong schema fails silently and you fall back to prose. Prose bullets are the fallback ONLY when NEITHER widget exists. Any turn that would end with a choice must be the widget \u2014 the widget IS the question.
+
+**If the tool result carries a \`next_steps\` object, that is the source of truth \u2014 use it directly.** Each option has a short \`.label\` (\u22645 words) and a full \`.description\`. Map \`next_steps.options[]\` into your host widget VERBATIM and in order: for \`AskUserQuestion\` (cowork / Claude Code) pass each as \`{label, description}\`; for \`ask_user_input_v0\` (Claude chat / ChatGPT, string options only) pass each option's \`.description\` as the string (it's the full sentence). Do NOT reword, reorder, drop, or prose-ify them \u2014 they're built deterministically by the server so the offer (incl. the artifact option at position 0) fires every time. Fall back to the table below only when there is NO \`next_steps\` field.
+
+**One exception \u2014 skip the widget** when the user's original message contained a complete sequential instruction chain ("show me X and then do Y") AND all stated steps have been completed. In that case, end with STOP directly \u2014 the user stated their full plan and does not need a "what next?" prompt.
+- Skip example: "Show me today's leads and then research the top one for me." \u2192 after research completes, emit STOP without the widget.
+- Do NOT skip for: plain requests ("show me today's leads", "run my check-in"), recurring-language requests ("I do this every day"), or requests where only one action was stated.
+
+Pick 2\u20134 rows from the (Observation, Suggest, Calls) table below most relevant to the response, then call your host's widget with ITS schema (per the schema rules above \u2014 wrong schema fails silently):
+- \`ask_user_input_v0\`: \`{questions:[{question,type:"single_select",options:["<Suggest 1>","<Suggest 2>"]}]}\`
+- \`AskUserQuestion\`: \`{questions:[{question,header:"Next step",multiSelect:false,options:[{label:"<\u22645 words>",description:"<Suggest 1>"}]}]}\`
+
+User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutually-exclusive options, AskUserQuestion labels \u22645 words (full text in \`description\`), max 3 questions. Table stays internal; never recite it.
+
+---
+
+
+
+Pick the ONE row matching the job's state and offer at most two options \u2014 this
+is a status tool, keep it terse:
+
+| Observation | Suggest | Calls |
+|---|---|---|
+| Still running | "Keep waiting (~1 min) or leave it \u2014 results are kept 30 days" | leadbay_lead_job_status(job_id, wait_seconds: 60) |
+| Terminal (completed / partial / failed) | Render the delivery per the RENDERING block, then offer the matching find_new_leads / qualify_leads NEXT STEPS | \u2014 |
+| \`expired\` (past the 30-day window) | "Re-read the billed leads from your delivery ledger" \u2014 there is nothing left to render: the job terminalized and its items are no longer listed, so do NOT present an empty delivery as a result | leadbay_qualify_leads(prior_deliveries: {job_id}) |
+`;
 var leadbay_like_lead = `## WHEN TO USE
 
 Trigger phrases: "I like this lead", "thumbs up", "this one looks good", "save this one", "this is a good fit", "more like this", "yes to this one".
@@ -7103,7 +7900,7 @@ var leadbay_pull_leads = `## WHEN TO USE
 
 Trigger phrases: "show me leads", "show me new leads", "show me today's leads", "today's prospects", "best new leads", "fresh leads", "what's new today".
 
-Do NOT use for: "leads I should follow up with" \u2192 \`leadbay_pull_followups\`; "I'm going to <city>" \u2192 \`leadbay_tour_plan\`; "I'm in <city> next week \u2014 who's worth meeting" \u2192 \`leadbay_tour_plan\`; "who should I meet in <city>" \u2192 \`leadbay_tour_plan\`; "visiting <city> \u2014 who's worth meeting / seeing" \u2192 \`leadbay_tour_plan\`; "leads I should reach out to" \u2192 \`leadbay_pull_followups\`; "leads to get back to" \u2192 \`leadbay_pull_followups\`; "leads to contact today" \u2192 \`leadbay_pull_followups\`; "should I contact" \u2192 \`leadbay_pull_followups\`; "reconnect with" \u2192 \`leadbay_pull_followups\`; "re-engage" \u2192 \`leadbay_pull_followups\`.
+Do NOT use for: "find me N companies that <specific profile>" \u2192 \`leadbay_find_new_leads\`; "new prospects like <company> with their emails" \u2192 \`leadbay_find_new_leads\`; "leads I should follow up with" \u2192 \`leadbay_pull_followups\`; "I'm going to <city>" \u2192 \`leadbay_tour_plan\`; "I'm in <city> next week \u2014 who's worth meeting" \u2192 \`leadbay_tour_plan\`; "who should I meet in <city>" \u2192 \`leadbay_tour_plan\`; "visiting <city> \u2014 who's worth meeting / seeing" \u2192 \`leadbay_tour_plan\`; "leads I should reach out to" \u2192 \`leadbay_pull_followups\`; "leads to get back to" \u2192 \`leadbay_pull_followups\`; "leads to contact today" \u2192 \`leadbay_pull_followups\`; "should I contact" \u2192 \`leadbay_pull_followups\`; "reconnect with" \u2192 \`leadbay_pull_followups\`; "re-engage" \u2192 \`leadbay_pull_followups\`.
 
 Prefer when: fresh Discover leads; if a lens is named, pass \`lensId\` and pin it
 
@@ -7112,6 +7909,7 @@ Examples that SHOULD invoke this tool:
 - "Pull my best new prospects."
 
 Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "Find me 10 gyms around Dallas that would buy our flooring."
 - "Which leads should I follow up with this week?"
 - "I'm flying to Berlin Thursday \u2014 who should I meet?"
 - "I'm in San Francisco next Tuesday \u2014 who's worth meeting?"
@@ -7141,7 +7939,7 @@ Every lead carries \`recommended_contact\` (with \`linkedin_page\` when the back
 
 WHEN TO USE: as the agent's default opening move when the user wants to see leads, or as a daily check-in for what's new today.
 
-WHEN NOT TO USE: when the user has named a specific lens \u2014 pass \`lensId\` to override the auto-resolution. Replaces the older leadbay_find_prospects (removed in v0.2.0).
+WHEN NOT TO USE: when the user has named a specific lens \u2014 pass \`lensId\` to override the auto-resolution.
 
 The active lens can change between calls (5-min cache + backend \`last_requested_lens\`). If a multi-step workflow depends on staying on one lens, **capture \`response.lens.id\` from the first response and pass it as the \`lensId\` argument on every subsequent Leadbay call** \u2014 including re-pulls, bulk qualifies, and research. (Field-name caveat: response nests it as \`lens.id\`; the parameter is \`lensId\`.) Re-pulling without \`lensId\` after a long-running tool may silently switch to a different lens and discard prior work.
 
@@ -7291,79 +8089,304 @@ 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\`.
 `;
-var 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:
+var leadbay_qualify_leads = `## WHEN TO USE
 
-- **\`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.
+Trigger phrases: "qualify these companies", "vet this list", "which of these fit our ICP", "score these websites / accounts", "get me the right contact at these companies", "re-qualify what you delivered last week".
 
-**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.
+Do NOT use for: "find me new leads / companies that <profile>" \u2192 \`leadbay_find_new_leads\`; "qualify the top N of my lens batch" \u2192 \`leadbay_bulk_qualify_leads\`; "import this CSV file" \u2192 \`leadbay_import_leads\`; "tell me about <one company> in depth" \u2192 \`leadbay_research_lead_by_name_fuzzy\`; "add emails to the contacts I selected" \u2192 \`leadbay_enrich_titles\`.
 
-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.
+Prefer when: the user points at SPECIFIC companies (ids, websites, names, a pasted list, "what you found yesterday") and wants fit verdicts and/or the right person to talk to.
 
-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.
+Examples that SHOULD invoke this tool:
+- "Here are 60 restaurant websites from my Austin sweep \u2014 which fit, and who's the owner?"
+- "Re-qualify last week's delivery and get phone numbers for the good ones."
+- "Vet these 12 accounts from my spreadsheet against our criteria."
 
-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.
+Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "Find me 10 new gyms in Texas."
+- "Qualify the top 10 leads in my batch."
+- "I have a CSV of 400 attendees to import."
 
-## A launched job cannot be stopped
+## RENDER (quick)
 
-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.
+3-col table for delivered items (fit bar + company / why-fits \u226420 words /
+contact + channels) in returned order, then a compact Ref \u2192 Outcome table
+for skipped refs (not_in_universe, low_confidence_identity, ... in plain
+words), then the honest funnel + cost line. Full algorithm below.
 
-**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.
+Submit a qualify batch over companies the org already has (or that exist in
+the Leadbay universe): each ref is resolved to a known company, freshly
+researched + AI-qualified against the org's questions / tags / ideal buyer
+profile (frozen at submit), matched to the requested contact titles, and \u2014
+when asked \u2014 enriched with verified channels. Answers arrive per-item from a
+job; this tool polls up to \`wait_seconds\` (default 45) and hands off to
+\`leadbay_lead_job_status\` when the batch needs longer.
+
+**Refs are flexible; outcomes are per-item.** \`lead_refs\` accepts any mix of
+\`lead_id\`, \`website\`, \`name\`(+\`location\`), or a stable \`contact_id\` from a
+prior result (enrichment then targets exactly that person, never a re-match).
+\`prior_deliveries\` expands past MCP deliveries into refs \u2014 billed leads stay
+re-readable this way even after the 30-day result window. Duplicates collapse.
+A ref that can't be served comes back \`skipped\` with an honest
+\`status_reason\` (\`not_in_universe\`, \`low_confidence_identity\` with the
+\`resolution.alternatives\` to choose from, \`no_matching_contact\`, ...) \u2014 that
+is an ANSWER about the ref, not an error, and it costs nothing.
+
+**Disqualified \u2260 dropped.** Companies the org owns that fail qualification
+are DELIVERED with their negative evidence (question verdicts, tag misses,
+IBP reasoning) \u2014 "here's why to skip this account" is a deliverable.
+
+**Cost \u2014 never spend silently.** Resolution and identity are free.
+\`qualify: true\` (the default) costs ~94 cost_cents per lead needing FRESH
+research+scoring \u2014 but repeat calls reuse every fresh cached stage
+(\`from_cache\` flags on the items) and converge to near-zero cost. \`channels\`
+purchase verified email (25c) / phone (250c) on success only;
+\`already_owned\` values cost nothing.
+
+The gate is enforced in code, not just here: a PAID call (\`qualify\` left at
+its default or set true, and/or any \`channels\`) is WITHHELD unless it carries
+\`confirm: true\`. Without it the tool submits nothing and returns
+\`mode: "needs_confirmation"\` with a real backend quote \u2014 show that quote to
+the user, get the go-ahead (an explicit "spend / get their emails" in their
+message counts), then re-call with \`confirm: true\`. \`confirm: false\` is a
+veto: nothing is submitted and no quote round-trip is made. A fully FREE
+call (\`qualify: false\`, no \`channels\`) needs no \`confirm\` and passes straight
+through. Set \`request_id\` and reuse it on retries of the same batch.
+
+**Limits**: 500 refs/job, 3 active jobs/org, 10 submits/hour (429 +
+Retry-After beyond \u2014 wait, don't hammer), 30-min job wall clock.
 
-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.
-`;
-var 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.
+## RENDERING \u2014 delivery table + honest funnel line
 
-WHEN TO USE: before leadbay_enrich_titles, to plan which titles to order.
+Render delivered leads (\`leads[]\`, i.e. items with status \`delivered\` or
+\`degraded\`) as a markdown table **in the order returned**. Exactly three
+columns. Then ALWAYS close with the funnel line (below) \u2014 even, especially,
+when nothing was delivered.
 
-WHEN NOT TO USE: when you already know the exact titles you want to enrich.
-`;
-var leadbay_refine_prompt = `## WHEN TO USE
+**Column 1 \u2014 Company**
 
-Trigger phrases: "focus on companies that <qualitative trait>", "I prefer leads that <behavior/characteristic>", "prioritize companies running their own IT", "deprioritize companies that just raised".
+- Line 1: 10-segment fit bar in inline-code backticks from \`lead.fit.score\`
+  (0-100): \`filled = round(score/10)\`, glyphs \`\u25B0\` filled / \`\u25B1\` empty. When
+  \`lead.fit.components.qualification.available\` is true AND \`ai_score > 0\`,
+  replace the LAST filled segment with \`\u2756\` (AI-confirmed cap). When
+  \`fit.available\` is false, render \`\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\` and say "unscored" in col 2.
+  Never print the numeric score.
+- Insert \`<br>\`, then: linked company name (target \`company.website\`, bare
+  hostnames get \`https://\`; unlinked plain text when absent) + \` \xB7 \` + short
+  location (City, ST / City, Country) + \` \xB7 \` + employees as \`min\u2013max\` (omit
+  when \`employees.known\` is false).
 
-Do NOT use for: "create a new lens / a lens specialized into <X>" \u2192 \`leadbay_new_lens\`; "add/remove <sector> to/from my <name> lens" \u2192 \`leadbay_adjust_audience\`; "narrow the audience to <sector> / <size>" \u2192 \`leadbay_adjust_audience\`; "show me / list / switch my lenses" \u2192 \`leadbay_my_lenses\`.
+**Column 2 \u2014 Why it fits**
 
-Prefer when: ADMIN-ONLY. Qualitative refinement of the active lens that sector/size can't express. Creating/naming/listing/switching/sector-editing a lens routes elsewhere. Non-admin user \u2192 do NOT pick this.
+- One sentence \u2264 20 words. Priority: \`fit.reasoning\` \u2192 gist of
+  \`company.description\` \u2192 top \`fit.components.qualification.matched_tags\`.
+- If the item status is \`degraded\` or a requested channel failed, append the
+  honest flag in italics, e.g. *(email could not be sourced)*.
 
-Examples that SHOULD invoke this tool:
-- "Focus on hospitals that run their own IT in-house."
-- "Prioritize companies that have recently expanded headcount."
+**Column 3 \u2014 Contact**
 
-Examples that should NOT invoke this tool (sound similar, route elsewhere):
-- "Create a lens specialized in automobile."
-- "Add fintech to my Joinery lens."
-- "Show me my lenses."
+- \`[Name](linkedin) \xB7 role\` (linked name mandatory when a LinkedIn URL
+  exists; plain name otherwise). Below it, the PURCHASED channels only:
+  \`\u2709 value\` / \`\u260E value\` inline as plain text (they auto-linkify).
+- Channel statuses: \`delivered\` \u2192 show value; \`already_owned\` \u2192 value +
+  *(already yours)*; \`masked\` \u2192 "on file \u2014 reveal via channels";
+  \`not_requested\` \u2192 omit; \`failed_*\` \u2192 *(no verified email/phone)*.
+- No contact on the item (\`contact\` null): render \`\u2014\` (title_gate \`prefer\`
+  delivers such rows flagged; say so in col 2 only when contact_titles were
+  requested).
+
+**The funnel line (mandatory, after the table):**
+
+One short line narrating the delivery honestly, from \`funnel\` + \`cost\` +
+\`explain.scope_notes\`:
+
+> Matched N \xB7 examined E \xB7 qualified Q \xB7 disqualified D \u2192 **delivered X of
+> the Y asked** \xB7 stopped: <stop_reason in plain words> \xB7 spent C.CC.
+
+**Money: divide, then symbol.** Every amount (\`cost.spent\`,
+\`estimated_cost.max\`, quotes) is \`cost_cents\` \u2014 divide by 100, two decimals,
+so \`165\` renders \`1.65\`, NEVER \`165.00\`. Symbol from the account region: US
+\`$\`, France \`\u20AC\`, unknown \u2192 bare. Never hard-code \`$\`: it misstates a charge.
+
+"of the Y asked" needs \`summary.items_requested\`, which submits carry but a
+later \`leadbay_lead_job_status\` snapshot does not. Without it write **delivered
+X** and stop \u2014 never back-fill Y from \`matched\`/\`examined\` (they count
+candidates), never guess it.
+
+Plain-word stop reasons: \`target_reached\` \u2192 omit (success), \`pool_exhausted\` \u2192
+"ran out of matching candidates", \`max_cost\` \u2192 "hit the cost cap", \`quota\` \u2192
+"hit an org quota", \`time_budget\` \u2192 "hit the 30-min time budget".
+
+**When \`delivered\` is 0**: NEVER say just "no results". Render no table; give
+the funnel line plus the relevant \`explain.scope_notes\` (the backend's own
+diagnosis), then propose the concrete fix (reshape the seed per the craft
+rules, lower \`min_ai_score\`, raise \`max_cost\`, drop a filter) as NEXT STEPS.
+
+**Weak batch**: when the BEST delivered \`fit.score\` is under 30, don't present
+the table as an answer \u2014 open with "weak matches only", show at most the top 3,
+propose reshaping the seed/filters first. The count was filled with
+barely-better-than-random candidates.
+
+**Sanity-check every row**: (a) geo \u2014 \`city\`/\`region\` must sit inside any
+requested fence; drop and call out leaks (same-named cities slip through).
+(b) When \`explain.seed_strategy\` is \`text_match_exemplars\` (the standard FR
+path), fit is calibrated for lead-to-lead distances, not exemplar centroids \u2014
+treat high scores skeptically and verify each row's \`description\`.
+
+**Skipped items** (\`skipped[]\`, qualify jobs mostly): render a compact second
+table \`Ref \u2192 Outcome\` translating \`status_reason\` to plain words:
+\`not_in_universe\` \u2192 "not in the Leadbay universe (import it first)",
+\`low_confidence_identity\` \u2192 "couldn't safely match \u2014 check \`resolution.alternatives\`",
+\`no_matching_contact\` \u2192 "no contact with the requested title",
+\`disqualified\` \u2192 "evaluated: does not fit" (evidence is in the item when owned),
+\`enrichment_failed\` \u2192 "channel could not be sourced (not billed)".
+
+**\`items_truncated\`**: rows are a PREFIX, not the batch. Say so, and offer
+\`leadbay_lead_job_status(job_id, since: next_since)\` for the rest.
+
+**Hide from the user:** UUIDs (keep for tool calls, never render), cursors,
+\`explain.model\`/\`intelligence_snapshot\`, raw \`distance\`/\`calibration\`,
+\`seq\`/\`from_cache\`, empty arrays.
 
-## RENDER (quick)
+## Linking a contact's name
 
-On success: confirm the refinement applied to the active lens. If a
-clarification was raised, surface its question (route via ask_user_input_v0).
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
+
+URL priority (first applicable wins):
+
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
+
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
+
+
+
+**Delivered \u2260 endorsed.** This tool DELIVERS org-owned companies that FAILED
+qualification, carrying their negative evidence \u2014 so a delivered item is not
+automatically a prospect. An item whose \`status_reason\` is \`disqualified\`, or
+whose \`fit.components.qualification\` is available with a negative \`ai_score\`,
+must NOT go in the fit table: its firmographic score can still be high, and a
+full bar beside "why it fits" reads as a recommendation to call an account the
+evaluation just rejected.
+
+Give those their own short section after the fit table, titled
+**Evaluated \u2014 does not fit**: linked company, then the verdict in plain
+words from the
+qualification evidence (failed question verdicts, missed tags, IBP reasoning).
+That is the deliverable \u2014 "here's why to skip this account" \u2014 not a defect to
+hide.
+
+
+---
+
+## NEXT STEPS \u2014 after a qualify_leads delivery
+
+**ALWAYS render NEXT STEPS via your host's next-step widget.** Use whichever is in your tool set \u2014 the NAME and SCHEMA differ: **\`ask_user_input_v0\`** (Claude chat / ChatGPT) takes plain-string options with \`type:"single_select"\`; **\`AskUserQuestion\`** (Claude cowork / Claude Code) takes object options \`{label, description}\` plus a required short \`header\` (\u226412 chars) and \`multiSelect\`, NO \`type\` field, and never add an "Other" option (the host adds it). Match the schema to the tool you actually have \u2014 the wrong schema fails silently and you fall back to prose. Prose bullets are the fallback ONLY when NEITHER widget exists. Any turn that would end with a choice must be the widget \u2014 the widget IS the question.
+
+**If the tool result carries a \`next_steps\` object, that is the source of truth \u2014 use it directly.** Each option has a short \`.label\` (\u22645 words) and a full \`.description\`. Map \`next_steps.options[]\` into your host widget VERBATIM and in order: for \`AskUserQuestion\` (cowork / Claude Code) pass each as \`{label, description}\`; for \`ask_user_input_v0\` (Claude chat / ChatGPT, string options only) pass each option's \`.description\` as the string (it's the full sentence). Do NOT reword, reorder, drop, or prose-ify them \u2014 they're built deterministically by the server so the offer (incl. the artifact option at position 0) fires every time. Fall back to the table below only when there is NO \`next_steps\` field.
+
+**One exception \u2014 skip the widget** when the user's original message contained a complete sequential instruction chain ("show me X and then do Y") AND all stated steps have been completed. In that case, end with STOP directly \u2014 the user stated their full plan and does not need a "what next?" prompt.
+- Skip example: "Show me today's leads and then research the top one for me." \u2192 after research completes, emit STOP without the widget.
+- Do NOT skip for: plain requests ("show me today's leads", "run my check-in"), recurring-language requests ("I do this every day"), or requests where only one action was stated.
+
+Pick 2\u20134 rows from the (Observation, Suggest, Calls) table below most relevant to the response, then call your host's widget with ITS schema (per the schema rules above \u2014 wrong schema fails silently):
+- \`ask_user_input_v0\`: \`{questions:[{question,type:"single_select",options:["<Suggest 1>","<Suggest 2>"]}]}\`
+- \`AskUserQuestion\`: \`{questions:[{question,header:"Next step",multiSelect:false,options:[{label:"<\u22645 words>",description:"<Suggest 1>"}]}]}\`
+
+User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutually-exclusive options, AskUserQuestion labels \u22645 words (full text in \`description\`), max 3 questions. Table stays internal; never recite it.
+
+---
+
+
+
+Pick the 2-3 options that match what actually happened:
+
+| Observation | Suggest | Calls |
+|---|---|---|
+| Job still running | "Check on it in ~1 min" | leadbay_lead_job_status(job_id, wait_seconds: 60) |
+| Fit leads with contacts delivered | "Draft outreach for the qualified ones" | leadbay_prepare_outreach |
+| Items skipped \`not_in_universe\` | "Import those companies first, then re-qualify" | leadbay_import_leads \u2192 leadbay_qualify_leads |
+| Items skipped \`low_confidence_identity\` | "Pick the right match" (show \`resolution.alternatives\`) | leadbay_qualify_leads with the chosen lead_id |
+| Contacts delivered without channels | "Purchase verified emails/phones for the keepers (state cost first)" | leadbay_qualify_leads(lead_refs with contact_id, channels) |
+| Disqualified with evidence | "Review why \u2014 adjust qualification questions if the criteria are off" | leadbay_get_qualification_questions |
+`;
+var 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:
+
+- **\`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.
+`;
+var 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.
+
+WHEN TO USE: before leadbay_enrich_titles, to plan which titles to order.
+
+WHEN NOT TO USE: when you already know the exact titles you want to enrich.
+`;
+var leadbay_refine_prompt = `## WHEN TO USE
+
+Trigger phrases: "focus on companies that <qualitative trait>", "I prefer leads that <behavior/characteristic>", "prioritize companies running their own IT", "deprioritize companies that just raised".
+
+Do NOT use for: "create a new lens / a lens specialized into <X>" \u2192 \`leadbay_new_lens\`; "add/remove <sector> to/from my <name> lens" \u2192 \`leadbay_adjust_audience\`; "narrow the audience to <sector> / <size>" \u2192 \`leadbay_adjust_audience\`; "show me / list / switch my lenses" \u2192 \`leadbay_my_lenses\`.
+
+Prefer when: ADMIN-ONLY. Qualitative refinement of the active lens that sector/size can't express. Creating/naming/listing/switching/sector-editing a lens routes elsewhere. Non-admin user \u2192 do NOT pick this.
+
+Examples that SHOULD invoke this tool:
+- "Focus on hospitals that run their own IT in-house."
+- "Prioritize companies that have recently expanded headcount."
+
+Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "Create a lens specialized in automobile."
+- "Add fintech to my Joinery lens."
+- "Show me my lenses."
+
+## RENDER (quick)
+
+On success: confirm the refinement applied to the active lens. If a
+clarification was raised, surface its question (route via ask_user_input_v0).
 
 ---
 
@@ -9019,6 +10042,255 @@ Keep it secondary \u2014 the three window gauges are the headline. Omit when nul
 WHEN TO USE: at the start of a session to know what the agent can/can't do, after a 429 to explain to the user which resource window was exhausted and when it resets, and after the user signals a top-up so the agent can resume the interrupted workflow.
 
 WHEN NOT TO USE: as a pre-flight gate before bulk ops \u2014 operations themselves return 429; this tool is for context, not gating. And: a recent quota snapshot showing "exhausted" is NOT a reason to refuse a write call when the user has just topped up \u2014 re-call this tool first, then proceed.
+`,
+  leadbay_find_new_leads: `## WHEN TO USE
+
+Trigger phrases: "find me N companies that <profile>", "get me new prospects like <company>", "I need leads in <place> that <do X>", "search for companies that would buy <product>", "net-new leads outside my current pipeline", "we're entering <market> \u2014 who should we target".
+
+Do NOT use for: "show me today's leads / what's new today" \u2192 \`leadbay_pull_leads\`; "find me new leads (no profile, no count named)" \u2192 \`leadbay_pull_leads\`; "more leads like the ones in my lens" \u2192 \`leadbay_extend_lens\`; "qualify / vet these companies I have" \u2192 \`leadbay_qualify_leads\`; "qualify the top N of my batch" \u2192 \`leadbay_bulk_qualify_leads\`; "leads I should follow up with" \u2192 \`leadbay_pull_followups\`; "tell me about <one company>" \u2192 \`leadbay_research_lead_by_name_fuzzy\`.
+
+Prefer when: the user describes a target profile or names a count of NEW companies \u2014 craft the example_lead per the seed rules below BEFORE calling; never pass the user's raw sentence as query.
+
+Examples that SHOULD invoke this tool:
+- "Find me 10 gyms around Dallas that would buy our flooring, with someone I can call."
+- "Get me 20 new US SaaS companies, 50-2000 employees, with the VP People's email."
+- "We're launching in Lyon \u2014 find 15 hotels that fit our ICP."
+
+Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "Show me today's leads."
+- "Which leads should I follow up with this week?"
+- "Qualify these 40 websites from my spreadsheet."
+
+## RENDER (quick)
+
+3-col table of delivered leads in returned order: col 1 = 10-segment fit
+bar + linked company \xB7 location \xB7 size; col 2 = why-fits \u226420 words; col 3
+= contact + purchased channels. ALWAYS close with the honest funnel line
+(matched/examined/delivered/stop reason/spend) \u2014 especially on 0
+delivered. Full algorithm below.
+
+---
+
+Submit a net-new lead search: the backend matches an ICP seed against the full
+company universe, applies hard filters, skips what the org already knows
+(\`novelty: org\`), optionally qualifies against the org's own intelligence
+(questions, tags, ideal buyer profile \u2014 frozen at submit), and optionally buys
+contact channels. Polls up to \`wait_seconds\` (default 45); a longer job returns
+\`still_running\` + \`next_poll\` \u2014 hand off to \`leadbay_lead_job_status\`. Jobs run
+\u226430 min, results kept 30 days.
+
+**Free vs paid \u2014 never spend silently.** Default (\`qualify: false\`,
+\`channels: []\`) is FREE: company profile + fit score + cached research +
+contact identity. Paid: \`qualify: true\` (~94 cost_cents per candidate
+EXAMINED, capped by \`exploration_cap\`/\`max_cost\`) and \`channels\` (email 25c /
+phone 250c, success-only). Enforced in code: a paid call is WITHHELD unless it
+carries \`confirm: true\` \u2014 nothing is submitted and you get
+\`mode: "needs_confirmation"\` with a real quote to show the user. Re-call with
+\`confirm: true\` on their go-ahead ("spend / get their emails" counts).
+\`confirm: false\` vetoes. Free needs no consent. **Preview free first** \u2014
+reshaping an off-profile seed is free, exploring it with \`qualify: true\` is
+not.
+
+**Ad-hoc exclusions ("no chains") are enforced by NO tier** \u2014 \`filters\` has no
+exclusion key, and \`qualify\` scores against the org's FROZEN questions and IBP,
+which need not mention chains; the seed's inverse only shifts ranking.
+Violators can survive, be paid for and be delivered \u2014 post-filter them yourself
+and say the tier didn't enforce it. Durable enforcement \u2192
+\`leadbay_refine_prompt\`.
+
+### Crafting the \`example_lead\` seed \u2014 the input that decides result quality
+
+The \`example_lead\` is a FICTIONAL typical ideal customer, matched against real
+registry/website descriptions \u2014 which state what a company **IS**, never what
+is happening. Write it the same way or the matcher drifts. Every rule below is
+measured:
+
+1. **Describe the BUYER, never the seller.** Ask: "would this company write a
+   check to my user?" A seed describing what the user SELLS surfaces their
+   *competitors and vendors*. If the product helps companies of type X serve
+   customers of type Y, the seed describes X \u2014 never Y.
+2. **Put everything in \`description\`; leave \`name\` unset.** An invented brand
+   name pulls matching toward name-lookalikes \u2014 a seed named "Meridian
+   Analytics" returned five unrelated "Meridian" companies.
+3. **Registry style, one sentence to ~250 chars.** Industry niche, business
+   model, what they sell or operate, who they serve, observable scale. Write
+   it like the first paragraph of their About-Us page.
+   - STRONG: "Operator of full-service fitness centers offering strength
+     areas, group classes and personal training to members across multiple
+     clubs."
+   - WEAK (generic): "A gym in Texas."
+   - WRONG (seller-side): "Supplier of durable modular flooring for gyms."
+4. **No event language.** "hiring", "expanding", "just raised" are not
+   filters \u2014 registry descriptions never contain them, so they dilute the
+   profile. Purchase triggers belong in the org's qualification questions.
+5. **No meta-markers.** Never "(example)", "(fictional)", "(placeholder)".
+6. **Hard constraints go in \`filters\`, not prose \u2014 exact keys:**
+   \`sectors: string[]\`, \`locations: string[]\`, \`employees_min: number\`,
+   \`employees_max: number\`. FLAT numbers \u2014 nested \`employees: {min, max}\`
+   exists only in RESULT payloads. \`example_lead.employees\` does not filter.
+   \`locations\` take city/state/region names ("Dallas, TX", "\xCEle-de-France");
+   a country name is refused in code \u2014 whole-country intent = omit it.
+7. **Prefer \`example_lead\` over \`query\`.** Query matches topic *vocabulary*:
+   "gyms that need durable flooring" surfaced flooring VENDORS, 0 delivered.
+   Use \`query\` only for signal an example can't express.
+8. **One seed per buyer archetype.** An ask spanning two segments ("gyms and
+   warehouses") needs one search each with its own description and
+   \`request_id\` \u2014 a blended seed lands between the clusters and matches
+   neither.
+
+
+**Parameter notes**
+- \`request_id\` (REQUIRED) is the retry contract: SAME value retrying the same
+  ask (same live job, no double spend); NEW for a changed ask. Derive from ask
+  + archetype + date: \`gyms-dallas-2026-07-28\`.
+- Never lower \`min_ai_score\` together with \`channels\` \u2014 that buys emails for
+  leads the AI just scored as junk.
+- \`count\` \u2264 50; \u22643 active jobs/org; \u226410 submits/hour (429 + Retry-After \u2014
+  wait, don't hammer).
+
+**Read the result honestly** \u2014 \`funnel\` + \`explain.scope_notes\` tell the story;
+zero delivered gets a cause and a next move (rules in RENDERING).
+
+---
+
+## RENDERING \u2014 delivery table + honest funnel line
+
+Render delivered leads (\`leads[]\`, i.e. items with status \`delivered\` or
+\`degraded\`) as a markdown table **in the order returned**. Exactly three
+columns. Then ALWAYS close with the funnel line (below) \u2014 even, especially,
+when nothing was delivered.
+
+**Column 1 \u2014 Company**
+
+- Line 1: 10-segment fit bar in inline-code backticks from \`lead.fit.score\`
+  (0-100): \`filled = round(score/10)\`, glyphs \`\u25B0\` filled / \`\u25B1\` empty. When
+  \`lead.fit.components.qualification.available\` is true AND \`ai_score > 0\`,
+  replace the LAST filled segment with \`\u2756\` (AI-confirmed cap). When
+  \`fit.available\` is false, render \`\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1\` and say "unscored" in col 2.
+  Never print the numeric score.
+- Insert \`<br>\`, then: linked company name (target \`company.website\`, bare
+  hostnames get \`https://\`; unlinked plain text when absent) + \` \xB7 \` + short
+  location (City, ST / City, Country) + \` \xB7 \` + employees as \`min\u2013max\` (omit
+  when \`employees.known\` is false).
+
+**Column 2 \u2014 Why it fits**
+
+- One sentence \u2264 20 words. Priority: \`fit.reasoning\` \u2192 gist of
+  \`company.description\` \u2192 top \`fit.components.qualification.matched_tags\`.
+- If the item status is \`degraded\` or a requested channel failed, append the
+  honest flag in italics, e.g. *(email could not be sourced)*.
+
+**Column 3 \u2014 Contact**
+
+- \`[Name](linkedin) \xB7 role\` (linked name mandatory when a LinkedIn URL
+  exists; plain name otherwise). Below it, the PURCHASED channels only:
+  \`\u2709 value\` / \`\u260E value\` inline as plain text (they auto-linkify).
+- Channel statuses: \`delivered\` \u2192 show value; \`already_owned\` \u2192 value +
+  *(already yours)*; \`masked\` \u2192 "on file \u2014 reveal via channels";
+  \`not_requested\` \u2192 omit; \`failed_*\` \u2192 *(no verified email/phone)*.
+- No contact on the item (\`contact\` null): render \`\u2014\` (title_gate \`prefer\`
+  delivers such rows flagged; say so in col 2 only when contact_titles were
+  requested).
+
+**The funnel line (mandatory, after the table):**
+
+One short line narrating the delivery honestly, from \`funnel\` + \`cost\` +
+\`explain.scope_notes\`:
+
+> Matched N \xB7 examined E \xB7 qualified Q \xB7 disqualified D \u2192 **delivered X of
+> the Y asked** \xB7 stopped: <stop_reason in plain words> \xB7 spent C.CC.
+
+**Money: divide, then symbol.** Every amount (\`cost.spent\`,
+\`estimated_cost.max\`, quotes) is \`cost_cents\` \u2014 divide by 100, two decimals,
+so \`165\` renders \`1.65\`, NEVER \`165.00\`. Symbol from the account region: US
+\`$\`, France \`\u20AC\`, unknown \u2192 bare. Never hard-code \`$\`: it misstates a charge.
+
+"of the Y asked" needs \`summary.items_requested\`, which submits carry but a
+later \`leadbay_lead_job_status\` snapshot does not. Without it write **delivered
+X** and stop \u2014 never back-fill Y from \`matched\`/\`examined\` (they count
+candidates), never guess it.
+
+Plain-word stop reasons: \`target_reached\` \u2192 omit (success), \`pool_exhausted\` \u2192
+"ran out of matching candidates", \`max_cost\` \u2192 "hit the cost cap", \`quota\` \u2192
+"hit an org quota", \`time_budget\` \u2192 "hit the 30-min time budget".
+
+**When \`delivered\` is 0**: NEVER say just "no results". Render no table; give
+the funnel line plus the relevant \`explain.scope_notes\` (the backend's own
+diagnosis), then propose the concrete fix (reshape the seed per the craft
+rules, lower \`min_ai_score\`, raise \`max_cost\`, drop a filter) as NEXT STEPS.
+
+**Weak batch**: when the BEST delivered \`fit.score\` is under 30, don't present
+the table as an answer \u2014 open with "weak matches only", show at most the top 3,
+propose reshaping the seed/filters first. The count was filled with
+barely-better-than-random candidates.
+
+**Sanity-check every row**: (a) geo \u2014 \`city\`/\`region\` must sit inside any
+requested fence; drop and call out leaks (same-named cities slip through).
+(b) When \`explain.seed_strategy\` is \`text_match_exemplars\` (the standard FR
+path), fit is calibrated for lead-to-lead distances, not exemplar centroids \u2014
+treat high scores skeptically and verify each row's \`description\`.
+
+**Skipped items** (\`skipped[]\`, qualify jobs mostly): render a compact second
+table \`Ref \u2192 Outcome\` translating \`status_reason\` to plain words:
+\`not_in_universe\` \u2192 "not in the Leadbay universe (import it first)",
+\`low_confidence_identity\` \u2192 "couldn't safely match \u2014 check \`resolution.alternatives\`",
+\`no_matching_contact\` \u2192 "no contact with the requested title",
+\`disqualified\` \u2192 "evaluated: does not fit" (evidence is in the item when owned),
+\`enrichment_failed\` \u2192 "channel could not be sourced (not billed)".
+
+**\`items_truncated\`**: rows are a PREFIX, not the batch. Say so, and offer
+\`leadbay_lead_job_status(job_id, since: next_since)\` for the rest.
+
+**Hide from the user:** UUIDs (keep for tool calls, never render), cursors,
+\`explain.model\`/\`intelligence_snapshot\`, raw \`distance\`/\`calibration\`,
+\`seq\`/\`from_cache\`, empty arrays.
+
+## Linking a contact's name
+
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
+
+URL priority (first applicable wins):
+
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
+
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
+
+
+
+---
+
+## NEXT STEPS \u2014 after a find_new_leads delivery
+
+**ALWAYS render NEXT STEPS via your host's next-step widget.** Use whichever is in your tool set \u2014 the NAME and SCHEMA differ: **\`ask_user_input_v0\`** (Claude chat / ChatGPT) takes plain-string options with \`type:"single_select"\`; **\`AskUserQuestion\`** (Claude cowork / Claude Code) takes object options \`{label, description}\` plus a required short \`header\` (\u226412 chars) and \`multiSelect\`, NO \`type\` field, and never add an "Other" option (the host adds it). Match the schema to the tool you actually have \u2014 the wrong schema fails silently and you fall back to prose. Prose bullets are the fallback ONLY when NEITHER widget exists. Any turn that would end with a choice must be the widget \u2014 the widget IS the question.
+
+**If the tool result carries a \`next_steps\` object, that is the source of truth \u2014 use it directly.** Each option has a short \`.label\` (\u22645 words) and a full \`.description\`. Map \`next_steps.options[]\` into your host widget VERBATIM and in order: for \`AskUserQuestion\` (cowork / Claude Code) pass each as \`{label, description}\`; for \`ask_user_input_v0\` (Claude chat / ChatGPT, string options only) pass each option's \`.description\` as the string (it's the full sentence). Do NOT reword, reorder, drop, or prose-ify them \u2014 they're built deterministically by the server so the offer (incl. the artifact option at position 0) fires every time. Fall back to the table below only when there is NO \`next_steps\` field.
+
+**One exception \u2014 skip the widget** when the user's original message contained a complete sequential instruction chain ("show me X and then do Y") AND all stated steps have been completed. In that case, end with STOP directly \u2014 the user stated their full plan and does not need a "what next?" prompt.
+- Skip example: "Show me today's leads and then research the top one for me." \u2192 after research completes, emit STOP without the widget.
+- Do NOT skip for: plain requests ("show me today's leads", "run my check-in"), recurring-language requests ("I do this every day"), or requests where only one action was stated.
+
+Pick 2\u20134 rows from the (Observation, Suggest, Calls) table below most relevant to the response, then call your host's widget with ITS schema (per the schema rules above \u2014 wrong schema fails silently):
+- \`ask_user_input_v0\`: \`{questions:[{question,type:"single_select",options:["<Suggest 1>","<Suggest 2>"]}]}\`
+- \`AskUserQuestion\`: \`{questions:[{question,header:"Next step",multiSelect:false,options:[{label:"<\u22645 words>",description:"<Suggest 1>"}]}]}\`
+
+User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutually-exclusive options, AskUserQuestion labels \u22645 words (full text in \`description\`), max 3 questions. Table stays internal; never recite it.
+
+---
+
+
+
+Pick the 2-3 options that match what actually happened \u2014 never all seven:
+
+| Observation | Suggest | Calls |
+|---|---|---|
+| Job still running (\`still_running: true\`) | "Check on it in ~1 min" | leadbay_lead_job_status(job_id, wait_seconds: 60) |
+| Free run delivered on-profile leads | "Qualify these N against your criteria (paid \u2014 \`dry_run\` first)" | leadbay_qualify_leads(prior_deliveries: {job_id}) |
+| Delivered leads look right | "Draft outreach for the top ones" | leadbay_prepare_outreach |
+| Delivered 0 or off-profile | "Reshape the example and retry" (name the fix from funnel + scope_notes) | leadbay_find_new_leads (NEW request_id) |
+| Stopped at cost cap (\`stop_reason: max_cost\`) | "Raise the cap to X and get the remaining N" \u2014 X in the account's currency per the funnel-line rule, never a hard-coded \`$\` | leadbay_find_new_leads, NEW request_id (same-id only dedupes onto a LIVE job) + higher max_cost + \`count\` = the SHORTFALL (\`items_requested\` \u2212 delivered), not the original + \`exclude_lead_ids\` = the examined-but-REJECTED ids (novelty covers delivered; these are what it misses \u2014 without them the rerun re-buys the same losers) |
+| Stopped on org quota (\`stop_reason: quota\`) | "Check which window is exhausted and when it resets" \u2014 never a re-run: it cannot clear an org quota and burns a submit slot to stop in the same place | leadbay_account_status |
+| User wants these tracked in Leadbay | "Add the keepers to a campaign" | leadbay_create_campaign / leadbay_add_leads_to_campaign |
 `,
   leadbay_scan_portfolio_signals: `## WHEN TO USE
 
@@ -15640,12 +16912,12 @@ var CITY_ALIASES = {
   vegas: "Las Vegas",
   nola: "New Orleans"
 };
-function expandAlias(text) {
-  const key = text.trim().toLowerCase();
-  return CITY_ALIASES[key] ?? text;
+function expandAlias(text2) {
+  const key = text2.trim().toLowerCase();
+  return CITY_ALIASES[key] ?? text2;
 }
-function scoreMatch(text, match) {
-  const t = text.trim().toLowerCase();
+function scoreMatch(text2, match) {
+  const t = text2.trim().toLowerCase();
   const n = match.name.trim().toLowerCase();
   if (n === t)
     return 1;
@@ -15668,8 +16940,8 @@ async function resolveLocations(client, texts) {
   const resolved = [...direct];
   const ambiguities = [];
   for (const originalText of free) {
-    const text = expandAlias(originalText);
-    const path = `/geo/search?q=${encodeURIComponent(text)}`;
+    const text2 = expandAlias(originalText);
+    const path = `/geo/search?q=${encodeURIComponent(text2)}`;
     let response;
     try {
       response = await client.request("GET", path);
@@ -15708,7 +16980,7 @@ async function resolveLocations(client, texts) {
       name: r.name,
       country: r.country,
       level: r.level,
-      score: scoreMatch(text, r)
+      score: scoreMatch(text2, r)
     })).sort((a, b) => {
       if (b.score !== a.score)
         return b.score - a.score;
@@ -16874,9 +18146,9 @@ ${firm.short_description}`);
       out.push(`### ${sec.section_emoji ?? ""} ${label}`.trim());
       const entries = Array.isArray(sec.entries) ? sec.entries : [];
       for (const e of entries.slice(0, 5)) {
-        const text = e.text ?? e.summary ?? JSON.stringify(e).slice(0, 200);
+        const text2 = e.text ?? e.summary ?? JSON.stringify(e).slice(0, 200);
         const hot = e.hot === true ? " \u{1F525}" : "";
-        out.push(`- ${text}${hot}`);
+        out.push(`- ${text2}${hot}`);
       }
       if (entries.length > 5)
         out.push(`- _${entries.length - 5} more \u2026_`);
@@ -21457,8 +22729,8 @@ function tokens(s) {
     return [];
   return s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
 }
-function bestMatches(text, taxonomy) {
-  const want = new Set(tokens(text));
+function bestMatches(text2, taxonomy) {
+  const want = new Set(tokens(text2));
   if (want.size === 0)
     return [];
   const ranked = taxonomy.map((s) => {
@@ -21487,12 +22759,12 @@ async function resolveSectors(client, texts, ctx) {
   }
   const resolved = [...direct];
   const ambiguities = [];
-  for (const text of free) {
-    const matches = bestMatches(text, taxonomy);
+  for (const text2 of free) {
+    const matches = bestMatches(text2, taxonomy);
     if (matches.length === 1 || matches.length >= 2 && matches[0].score >= 0.66 && matches[0].score - matches[1].score >= 0.34) {
       resolved.push(matches[0].id);
     } else {
-      ambiguities.push({ sector_text: text, matches });
+      ambiguities.push({ sector_text: text2, matches });
     }
   }
   return { resolved, ambiguities };
@@ -22157,50 +23429,1266 @@ var seedCandidates = {
   }
 };
 
-// ../core/dist/composite/extend-lens.js
-function httpStatus(err) {
-  return err?._meta?.http_status;
-}
-async function readExtraRefillQuota(client) {
-  try {
-    const me = await client.resolveMe();
-    const quota = await client.request("GET", `/organizations/${me.organization.id}/quota_status`);
-    const isRefill = (r) => r.resource_type?.toUpperCase() === "LENS_EXTRA_REFILL";
-    const entry = quota.org?.resources?.find(isRefill) ?? quota.user?.resources?.find(isRefill);
-    return {
-      count: entry?.count ?? null,
-      resets_at: entry?.resets_at ?? null
+// ../core/dist/composite/_mcp-job-helpers.js
+import { createHash as createHash4 } from "crypto";
+var TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
+  "completed",
+  "completed_partial",
+  "failed",
+  "expired"
+]);
+var MCP_JOB_POLL = { intervalMs: 4e3 };
+var SNAPSHOT_TIMEOUT_MS = 3e4;
+var PAGE_LIMIT = 100;
+var MAX_JOB_ITEMS = 1e3;
+var MIN_PAGES = 20;
+var maxPagesFor = (pageLimit) => Math.max(MIN_PAGES, Math.ceil(MAX_JOB_ITEMS / pageLimit) + 1);
+var JOB_ID_CHARSET = /^[A-Za-z0-9._~-]+$/;
+var MAX_JOB_ID_LENGTH = 200;
+function assertSafeJobId(jobId) {
+  const reject = (why) => {
+    throw {
+      error: true,
+      code: "INVALID_JOB_ID",
+      message: `job_id ${why}.`,
+      hint: "Pass the job_id exactly as leadbay_find_new_leads or leadbay_qualify_leads returned it \u2014 it is an opaque handle, not a path."
     };
-  } catch {
-    return { count: null, resets_at: null };
+  };
+  if (typeof jobId !== "string" || jobId.length === 0)
+    return reject("must be a non-empty string");
+  if (jobId.length > MAX_JOB_ID_LENGTH)
+    return reject(`is ${jobId.length} chars \u2014 the maximum is ${MAX_JOB_ID_LENGTH}`);
+  if (/^\.+$/.test(jobId))
+    return reject("cannot be a dot segment");
+  if (!JOB_ID_CHARSET.test(jobId))
+    return reject("contains characters that are not valid in a job handle");
+  return encodeURIComponent(jobId);
+}
+async function collectJobSnapshot(client, jobId, since, limit, signal, timeoutMs = SNAPSHOT_TIMEOUT_MS) {
+  if (signal?.aborted)
+    throw cancelledError(jobId);
+  const pageLimit = Math.min(Math.max(limit ?? PAGE_LIMIT, 1), PAGE_LIMIT);
+  const safeJobId = assertSafeJobId(jobId);
+  const qs = (cursor2) => `/mcp/jobs/${safeJobId}?limit=${pageLimit}` + (cursor2 ? `&since=${encodeURIComponent(cursor2)}` : "");
+  const maxPages = maxPagesFor(pageLimit);
+  const deadlineAt = Date.now() + timeoutMs;
+  const remaining = () => deadlineAt - Date.now();
+  let page = await client.request("GET", qs(since), void 0, {
+    signal,
+    // totalTimeoutMs, not timeoutMs: what is left of the wait must cover a 401
+    // backoff and its retry too, or a blip buys the poll a second full budget.
+    totalTimeoutMs: remaining()
+  });
+  const items = [...page.items];
+  let cursor = page.next_since ?? since ?? null;
+  let pages = 1;
+  while (page.items.length >= pageLimit && page.next_since && pages < maxPages && !signal?.aborted) {
+    if (remaining() <= 0)
+      break;
+    let next;
+    try {
+      next = await client.request("GET", qs(page.next_since), void 0, { signal, totalTimeoutMs: remaining() });
+    } catch (e) {
+      if (isTimeout(e))
+        break;
+      throw e;
+    }
+    items.push(...next.items);
+    pages += 1;
+    page = next;
+    if (next.items.length === 0) {
+      break;
+    }
+    cursor = next.next_since ?? cursor;
   }
+  const itemsTruncated = page.items.length >= pageLimit && !!page.next_since;
+  return {
+    ...page,
+    items,
+    next_since: cursor,
+    ...itemsTruncated ? { items_truncated: true } : {}
+  };
 }
-async function readAvailablePool(client, lensId) {
+function sleepUnlessAborted(ms, signal) {
+  if (signal?.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function cancelledError(jobId) {
+  return {
+    error: true,
+    code: "REQUEST_CANCELLED",
+    message: `The wait for job ${jobId} was cancelled before any status was read.`,
+    hint: "The job itself is backend-owned and keeps running. Poll leadbay_lead_job_status when you want its result."
+  };
+}
+function snapshotBudget(remainingMs) {
+  return Math.min(SNAPSHOT_TIMEOUT_MS, Math.max(remainingMs, 1));
+}
+function isTimeout(e) {
+  return typeof e === "object" && e !== null && e.code === "TIMEOUT";
+}
+function jobReadTimedOutError(jobId, waitSeconds) {
+  return {
+    error: true,
+    code: "JOB_READ_TIMEOUT",
+    // Structured, not just interpolated: a caller recovering programmatically
+    // should not have to parse the message to find the handle.
+    job_id: jobId,
+    message: `Job ${jobId} was submitted and is running, but its status could not be read within ${waitSeconds}s.`,
+    hint: `Pass job_id ${jobId} to leadbay_lead_job_status to read it \u2014 the job is backend-owned, still running, and its results are kept for 30 days.`
+  };
+}
+function jobHandleError(jobId, cause) {
+  const c = cause;
+  if (c?.job_id === jobId)
+    return cause;
+  return {
+    error: true,
+    code: c?.code ?? "JOB_READ_FAILED",
+    job_id: jobId,
+    message: `Job ${jobId} was submitted and is running, but reading its status failed: ${c?.message ?? String(cause)}`,
+    hint: `Pass job_id ${jobId} to leadbay_lead_job_status to read it \u2014 the job is backend-owned, keeps running whatever happened to this call, and its results are kept for 30 days.`
+  };
+}
+async function snapshotAfterSubmit(client, jobId, waitSeconds, ctx, itemsRequested) {
   try {
-    const preview = await client.request("GET", `/lenses/${lensId}/extra_refill_preview`);
-    return typeof preview?.available_count === "number" ? preview.available_count : null;
-  } catch {
-    return null;
+    return waitSeconds > 0 ? await waitForJob(client, jobId, waitSeconds, ctx, itemsRequested) : await collectJobSnapshot(client, jobId, void 0, void 0, ctx?.signal);
+  } catch (e) {
+    throw jobHandleError(jobId, e);
   }
 }
-async function readLensLeadTotal(client, lensId) {
+async function waitForJob(client, jobId, waitSeconds, ctx, itemsRequested, since, limit) {
+  const startedAt = Date.now();
+  const remainingMsOf = () => waitSeconds * 1e3 - (Date.now() - startedAt);
+  if (ctx?.signal?.aborted)
+    throw cancelledError(jobId);
+  let snap;
   try {
-    const page = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=1&page=0`);
-    return typeof page?.pagination?.total === "number" ? page.pagination.total : null;
-  } catch {
-    return null;
+    snap = await collectJobSnapshot(client, jobId, since, limit, ctx?.signal, snapshotBudget(remainingMsOf()));
+  } catch (e) {
+    if (isTimeout(e))
+      throw jobReadTimedOutError(jobId, waitSeconds);
+    throw e;
+  }
+  while (!TERMINAL_JOB_STATES.has(snap.job.state) && (Date.now() - startedAt) / 1e3 < waitSeconds && !ctx?.signal?.aborted) {
+    const remainingMs = waitSeconds * 1e3 - (Date.now() - startedAt);
+    if (remainingMs <= 0)
+      break;
+    await sleepUnlessAborted(Math.min(MCP_JOB_POLL.intervalMs, remainingMs), ctx?.signal);
+    if (ctx?.signal?.aborted)
+      break;
+    if (remainingMsOf() <= 0)
+      break;
+    try {
+      const fresh = await collectJobSnapshot(client, jobId, since, limit, ctx?.signal, snapshotBudget(remainingMsOf()));
+      const regressed = fresh.items.length < snap.items.length;
+      snap = regressed ? {
+        ...fresh,
+        items: snap.items,
+        next_since: snap.next_since ?? fresh.next_since,
+        ...snap.items_truncated ? { items_truncated: true } : {}
+      } : fresh;
+    } catch (e) {
+      if (ctx?.signal?.aborted)
+        break;
+      if (isTimeout(e))
+        break;
+      throw e;
+    }
+    const f = snap.funnel;
+    ctx?.progress?.({
+      progress: f.delivered ?? 0,
+      total: itemsRequested,
+      message: `${snap.job.state}: ${f.examined ?? 0} examined, ${f.delivered ?? 0} delivered, ${snap.cost.spent}c spent`
+    });
   }
+  return snap;
 }
-function noCandidatesReason(held, shape) {
-  const { geoSentence, ...extras } = shape;
-  const futile = " Extending again is futile \u2014 a refill on a lens with an empty candidate pool reports queued, consumes no quota and delivers nothing.";
-  if (held === 0) {
-    return {
-      code: "audience_too_narrow",
-      retryable: false,
-      message: "This lens holds no leads and has none left to add: its criteria intersect to nothing." + geoSentence + futile + " Tell the user which criteria are in play and offer to widen the audience (leadbay_adjust_audience).",
-      ...extras
-    };
+function refIdentity(ref) {
+  if (!ref || typeof ref !== "object" || Array.isArray(ref))
+    return null;
+  const o = ref;
+  const str = (f) => {
+    const v = o[f];
+    if (typeof v !== "string")
+      return null;
+    const t = v.trim().toLowerCase();
+    return t ? t : null;
+  };
+  const website = str("website");
+  const parts = [
+    normalizeUuid(o.lead_id) ?? null,
+    normalizeUuid(o.contact_id) ?? null,
+    website ? normalizeDomain(website) ?? website : null,
+    str("name"),
+    str("location")
+  ];
+  return parts.some((p) => p !== null) ? JSON.stringify(parts) : null;
+}
+function remapInputIndexes(items, refs) {
+  const list = Array.isArray(refs) ? refs : [];
+  if (list.length === 0)
+    return { items, remapped: false };
+  const byIdentity = /* @__PURE__ */ new Map();
+  list.forEach((ref, i) => {
+    const key = refIdentity(ref);
+    if (!key)
+      return;
+    const at = byIdentity.get(key);
+    if (at)
+      at.push(i);
+    else
+      byIdentity.set(key, [i]);
+  });
+  const next = [];
+  let ok = true;
+  for (const item of items) {
+    const ref = item.ref;
+    if (!ref || ref.input_indexes == null) {
+      next.push(item);
+      continue;
+    }
+    const key = refIdentity(ref.requested_as) ?? refIdentity({ lead_id: ref.lead_id ?? void 0 });
+    const found = key ? byIdentity.get(key) : void 0;
+    if (!found) {
+      ok = false;
+      break;
+    }
+    next.push({ ...item, ref: { ...ref, input_indexes: found } });
+  }
+  if (!ok) {
+    return {
+      items: items.map((item) => item.ref && item.ref.input_indexes != null ? { ...item, ref: { ...item.ref, input_indexes: null } } : item),
+      remapped: false
+    };
+  }
+  return { items: next, remapped: true };
+}
+function canonicalSet(values) {
+  const list = values === void 0 || values === null ? [] : Array.isArray(values) ? values : [values];
+  return [...new Set(list.map((v) => JSON.stringify(v)))].sort().map((v) => JSON.parse(v));
+}
+function coerceArrayParams(params, keys) {
+  const out = { ...params };
+  for (const key of keys) {
+    const v = out[key];
+    if (v !== void 0 && v !== null && !Array.isArray(v)) {
+      out[key] = [v];
+    }
+  }
+  return out;
+}
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function presentRequestId(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isUuidShaped(value) {
+  return typeof value === "string" && UUID_RE2.test(value.trim());
+}
+function normalizeUuid(value) {
+  if (typeof value !== "string")
+    return null;
+  const v = value.trim();
+  if (!v)
+    return null;
+  return UUID_RE2.test(v) ? v.toLowerCase() : v;
+}
+function canonicalIdSet(values) {
+  const list = values === void 0 || values === null ? [] : Array.isArray(values) ? values : [values];
+  return canonicalSet(list.map(normalizeUuid).filter((v) => !!v));
+}
+function canonicalLabelSet(values) {
+  const list = values === void 0 || values === null ? [] : Array.isArray(values) ? values : [values];
+  return canonicalSet(list.filter((v) => typeof v === "string").map((v) => v.trim().toLowerCase()).filter(Boolean));
+}
+function canonicalOptionalObject(value) {
+  if (!value)
+    return null;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (v === void 0 || v === null)
+      continue;
+    if (Array.isArray(v) && v.length === 0)
+      continue;
+    out[k] = v;
+  }
+  return Object.keys(out).length === 0 ? null : out;
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of Object.keys(value).sort()) {
+      out[k] = canonicalize(value[k]);
+    }
+    return out;
+  }
+  return value;
+}
+function derivedKey(prefix, shape) {
+  const serialized = typeof shape === "string" ? shape : JSON.stringify(canonicalize(shape));
+  return `${prefix}-${createHash4("sha256").update(serialized).digest("hex").slice(0, 32)}`;
+}
+function mockedSubmitPreview(submit, tool, region) {
+  const s = submit ?? {};
+  if (typeof s.job_id === "string" && s.job_id)
+    return null;
+  if (process.env.LEADBAY_MOCK !== "1") {
+    throw {
+      error: true,
+      code: "MALFORMED_SUBMIT_RESPONSE",
+      message: `${tool}: the submit succeeded but the response carried no job_id, so the job cannot be polled.`,
+      hint: "The job may still be running server-side. Do not re-submit blindly \u2014 reuse the same request_id so a retry dedupes instead of double-spending."
+    };
+  }
+  return {
+    mocked: true,
+    tool,
+    submitted: false,
+    would_call: s.would_call ?? null,
+    note: "LEADBAY_MOCK=1 \u2014 the job was not submitted, so there is no job to poll.",
+    region
+  };
+}
+function splitItems(snapshot) {
+  const leads = [];
+  const skipped = [];
+  for (const item of snapshot.items) {
+    if (item.status === "skipped")
+      skipped.push(item);
+    else
+      leads.push(item);
+  }
+  return { leads, skipped };
+}
+function compactBody(body) {
+  return Object.fromEntries(Object.entries(body).filter(([, v]) => v !== void 0));
+}
+var COUNTRY_ALIASES = [
+  "united states",
+  "united states of america",
+  "usa",
+  "us",
+  "america",
+  "etats unis",
+  "etats unis d amerique",
+  "france",
+  "fr",
+  "french republic",
+  "republique francaise"
+];
+var SUBNATIONAL_EXEMPTIONS = {
+  us: new Set(["georgia", "georgie"].map(countryKey2)),
+  fr: new Set([
+    "guadeloupe",
+    "martinique",
+    "reunion",
+    "mayotte",
+    "french guiana",
+    "guyane francaise",
+    "new caledonia",
+    "nouvelle caledonie",
+    "french polynesia",
+    "polynesie francaise",
+    "saint martin",
+    "saint barthelemy",
+    "saint pierre and miquelon",
+    "saint pierre et miquelon",
+    "wallis and futuna",
+    "wallis et futuna"
+  ].map(countryKey2))
+};
+var ALL_EXEMPTIONS = new Set(Object.values(SUBNATIONAL_EXEMPTIONS).flatMap((s) => [...s]));
+function exemptionsFor(region) {
+  const key = typeof region === "string" ? region.trim().toLowerCase() : "";
+  return SUBNATIONAL_EXEMPTIONS[key] ?? ALL_EXEMPTIONS;
+}
+function buildCountryLocationValues() {
+  const values = new Set(COUNTRY_ALIASES.map(countryKey2));
+  try {
+    const A = "A".charCodeAt(0);
+    const displays = ["en", "fr"].map((locale) => new Intl.DisplayNames([locale], { type: "region", fallback: "none" }));
+    for (let i = 0; i < 26; i++) {
+      for (let j = 0; j < 26; j++) {
+        const code = String.fromCharCode(A + i) + String.fromCharCode(A + j);
+        for (const display of displays) {
+          const name = display.of(code);
+          if (!name || name === code)
+            continue;
+          values.add(countryKey2(name));
+        }
+      }
+    }
+  } catch {
+  }
+  return values;
+}
+var COUNTRY_LOCATION_VALUES = buildCountryLocationValues();
+function countryKey2(raw) {
+  return raw.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[-_,]/g, " ").replace(/^\s*(l|d)['’]\s*/, "").replace(/['’.]/g, "").replace(/\s+/g, " ").trim().replace(/^(les|the|la|le|l)\s+/, "").trim();
+}
+var MAX_EXCLUDE_LEAD_IDS = 500;
+function rejectMalformedExclusions(ids) {
+  if (ids === void 0 || ids === null)
+    return;
+  const list = Array.isArray(ids) ? ids : [ids];
+  const bad = [];
+  list.forEach((v, i) => {
+    if (typeof v !== "string") {
+      bad.push(`${i} (${v === null ? "null" : typeof v})`);
+    } else if (!v.trim()) {
+      bad.push(`${i} (blank)`);
+    }
+  });
+  if (bad.length === 0)
+    return;
+  throw {
+    error: true,
+    code: "INVALID_EXCLUDE_LEAD_ID",
+    message: `exclude_lead_ids has ${bad.length} entr${bad.length === 1 ? "y" : "ies"} that is not a lead id: ${bad.join(", ")}.`,
+    hint: "Drop or fix those entries and re-call \u2014 every entry must be a non-blank lead id string. Silently skipping them would run the search without an exclusion you asked for, and could re-deliver and charge for that exact lead."
+  };
+}
+function rejectOversizedExclusions(ids) {
+  if (ids === void 0 || ids === null)
+    return;
+  const unique = canonicalIdSet(ids);
+  if (unique.length <= MAX_EXCLUDE_LEAD_IDS)
+    return;
+  throw {
+    error: true,
+    code: "TOO_MANY_EXCLUSIONS",
+    message: `exclude_lead_ids carries ${unique.length} ids \u2014 the maximum is ${MAX_EXCLUDE_LEAD_IDS}.`,
+    hint: "Drop the DELIVERED ids first: novelty:'org' already excludes those. Send the examined-but-rejected ones (disqualified + skipped), most recent first, capped at 500."
+  };
+}
+var MAX_LEAD_REFS = 500;
+function rejectOversizedLeadRefs(refs) {
+  if (refs === void 0 || refs === null)
+    return;
+  const list = Array.isArray(refs) ? refs : [refs];
+  const unique = /* @__PURE__ */ new Set();
+  let unkeyed = 0;
+  for (const ref of list) {
+    const key = refIdentity(ref);
+    if (key === null)
+      unkeyed += 1;
+    else
+      unique.add(key);
+  }
+  const count = unique.size + unkeyed;
+  if (count <= MAX_LEAD_REFS)
+    return;
+  throw {
+    error: true,
+    code: "TOO_MANY_LEAD_REFS",
+    message: `lead_refs carries ${count} companies \u2014 the maximum is ${MAX_LEAD_REFS}.`,
+    hint: `Split the batch into runs of ${MAX_LEAD_REFS} or fewer and call leadbay_qualify_leads once per run, each with its OWN request_id. Results accumulate in the org ledger, so a later run can re-read the earlier ones via prior_deliveries.`
+  };
+}
+function readSpendFlag(value, field) {
+  if (value === void 0 || value === null)
+    return void 0;
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    const t = value.trim().toLowerCase();
+    if (t === "true")
+      return true;
+    if (t === "false")
+      return false;
+  }
+  throw {
+    error: true,
+    code: "BAD_INPUT",
+    message: `${field} must be a boolean (got ${Array.isArray(value) ? "array" : typeof value}: ${JSON.stringify(value)}).`,
+    hint: `Re-call the tool with ${field}: true or ${field}: false as a JSON boolean, not a string or a number. This flag decides whether the user is charged, so an unrecognised value is refused rather than guessed.`
+  };
+}
+function rejectCountryLocations(locations, region) {
+  if (locations === void 0 || locations === null)
+    return;
+  const exempt = exemptionsFor(region);
+  const list = Array.isArray(locations) ? locations : [locations];
+  for (const loc of list) {
+    if (typeof loc !== "string")
+      continue;
+    const key = countryKey2(loc);
+    if (!exempt.has(key) && COUNTRY_LOCATION_VALUES.has(key)) {
+      throw {
+        error: true,
+        code: "COUNTRY_LEVEL_LOCATION",
+        message: `filters.locations value "${loc}" is country-level \u2014 it would silently fence the search to a same-named town, not the whole country.`,
+        hint: 'Whole-country intent = OMIT filters.locations entirely (each universe is single-country). Use city/state/region names for narrower fences. If you meant a town that shares the name, qualify it with its state or region (e.g. "Lebanon, Kentucky").'
+      };
+    }
+  }
+}
+function normalizeSearchFilters(filters) {
+  if (filters == null)
+    return void 0;
+  const { employees, employeesMin, employeesMax, ...rest } = filters;
+  const out = { ...rest };
+  if (out.employees_min == null) {
+    out.employees_min = employees?.min ?? employees?.employees_min ?? employeesMin;
+  }
+  if (out.employees_max == null) {
+    out.employees_max = employees?.max ?? employees?.employees_max ?? employeesMax;
+  }
+  if (out.employees_min == null)
+    delete out.employees_min;
+  if (out.employees_max == null)
+    delete out.employees_max;
+  for (const key of ["sectors", "locations"]) {
+    const v = out[key];
+    if (typeof v === "string")
+      out[key] = v.trim() ? [v] : void 0;
+    if (out[key] === void 0)
+      delete out[key];
+  }
+  return out;
+}
+function clampWaitSeconds(requested, fallback) {
+  if (requested == null || Number.isNaN(requested))
+    return fallback;
+  return Math.min(Math.max(requested, 0), 180);
+}
+
+// ../core/dist/composite/find-new-leads.js
+var DEFAULT_WAIT_SECONDS = 45;
+function sortFilterLists(filters) {
+  if (!filters)
+    return null;
+  const out = { ...filters };
+  for (const key of ["sectors", "locations"]) {
+    if (Array.isArray(out[key])) {
+      out[key] = canonicalLabelSet(out[key]);
+    }
+  }
+  return out;
+}
+var findNewLeads = {
+  name: "leadbay_find_new_leads",
+  annotations: {
+    title: "Find new leads (net-new ICP search)",
+    readOnlyHint: false,
+    // The tool CAN bill (qualify:true and/or channels) and records deliveries
+    // in the org novelty ledger, so it advertises destructive like the other
+    // paid composites — annotations are static and must describe the worst
+    // case, not the default. The free path is protected in execute() instead:
+    // a paid call is withheld until `confirm: true`.
+    destructiveHint: true,
+    // The mandatory request_id dedups: re-submitting the same request returns
+    // the SAME live job instead of double-spending.
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  write: true,
+  description: leadbay_find_new_leads,
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Natural-language ICP ask. Matches topic VOCABULARY \u2014 can surface vendors of a product as easily as buyers of it. Prefer example_lead; use query only when the user's wording carries signal an example can't."
+      },
+      example_lead: {
+        type: "object",
+        description: "A FICTIONAL typical ideal customer used as a look-alike seed \u2014 the highest-leverage input. Put everything in `description` (registry 'About Us' style, what the company IS); leave `name` unset (a distinctive invented name pulls matches toward name-lookalikes).",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          location: { type: "string" },
+          employees: { type: "number" }
+        },
+        additionalProperties: false
+      },
+      filters: {
+        type: "object",
+        description: "HARD constraints (the seed only shapes ranking). Sector/location labels resolve at submit; an unresolvable value is a 400 naming it.",
+        properties: {
+          sectors: { type: "array", items: { type: "string" } },
+          locations: { type: "array", items: { type: "string" } },
+          employees_min: { type: "number" },
+          employees_max: { type: "number" }
+        },
+        additionalProperties: false
+      },
+      count: {
+        type: "number",
+        description: "Target DELIVERED leads, 1-50. With qualify:true this means n SURVIVORS of qualification, not n candidates examined."
+      },
+      qualify: {
+        type: "boolean",
+        description: "Run fresh AI qualification and drop candidates scoring below min_ai_score. PAID: ~94 cost_cents per candidate EXAMINED (survivor or not). Default false (free)."
+      },
+      min_ai_score: {
+        type: "number",
+        description: "Disqualification floor on the [-30,+30] qualification DELTA (not the 0-100 fit score). Default 0. Lower to -30 to keep every evaluated lead with its evidence."
+      },
+      contact_titles: {
+        type: "array",
+        items: { type: "string" },
+        description: "Wanted decision-maker titles (max 10), matched semantically cross-language."
+      },
+      title_gate: {
+        type: "string",
+        enum: ["strict", "prefer"],
+        description: "strict = only leads with a matching known contact; prefer (default when contact_titles set) = matched first, rest flagged."
+      },
+      channels: {
+        type: "array",
+        items: { type: "string", enum: ["email", "phone"] },
+        description: "Contact channels to PURCHASE (email 25c, phone 250c, billed on success only). Empty = free identity tier."
+      },
+      exclude_lead_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Caller-side novelty belt on top of the server-side one (max 500 ids \u2014 over that the call is refused, so drop the DELIVERED ids first: novelty:'org' already covers those, and the examined-but-rejected ones are what it misses)."
+      },
+      novelty: {
+        type: "string",
+        enum: ["org", "none"],
+        description: "org (default) = only companies NEW to the org (excludes org leads, lens members, CRM ids, prior MCP deliveries)."
+      },
+      max_cost: {
+        type: "number",
+        description: "Spend cap for the whole job in cost_cents. Defaults by plan tier (500/2000/5000). The job stops honestly at the cap (stop_reason max_cost)."
+      },
+      exploration_cap: {
+        type: "number",
+        description: "Max candidates the qualify gate may examine. Default min(3n,150), ceiling min(20n,1000)."
+      },
+      request_id: {
+        type: "string",
+        description: "REQUIRED idempotency key. Derive it from the ask (e.g. 'gyms-texas-2026-07-28'); REUSE the exact same value when retrying the same ask \u2014 a duplicate returns the SAME job instead of double-spending. Use a NEW value only for a genuinely new ask."
+      },
+      lang: { type: "string", description: "Output language (default: user's language)." },
+      confirm: {
+        type: "boolean",
+        description: "Explicit spend decision, required only for a PAID search (qualify:true and/or channels). true = the user approved the quote, go ahead. false = a veto (returns mode:'needs_confirmation', spends nothing). Omitted on a paid call \u2192 the tool withholds the submit and returns a free quote to show the user first. The default FREE search (no qualify, no channels) needs no confirm."
+      },
+      dry_run: {
+        type: "boolean",
+        description: "Validate + worst-case cost estimate + quota forecast. No job, no spend. Use before the first PAID run of a session."
+      },
+      wait_seconds: {
+        type: "number",
+        description: "How long to poll before returning (default 45, max 180, 0 = submit + one snapshot). Free searches usually finish inside the window; paid exploration can take minutes \u2014 the result then carries still_running:true and the job_id to check with leadbay_lead_job_status."
+      }
+    },
+    required: ["count", "request_id"],
+    additionalProperties: false
+  },
+  execute: async (client, params, ctx) => {
+    params = coerceArrayParams(params, [
+      "contact_titles",
+      "channels",
+      "exclude_lead_ids"
+    ]);
+    rejectCountryLocations(params.filters?.locations, client.region);
+    rejectMalformedExclusions(params.exclude_lead_ids);
+    rejectOversizedExclusions(params.exclude_lead_ids);
+    const qualify = readSpendFlag(params.qualify, "qualify");
+    const dryRun = readSpendFlag(params.dry_run, "dry_run");
+    const confirm = readSpendFlag(params.confirm, "confirm");
+    params = { ...params, qualify, dry_run: dryRun, confirm };
+    const buysChannels = (params.channels?.length ?? 0) > 0;
+    const buysQualification = qualify === true;
+    const isPaid = buysQualification || buysChannels;
+    const vetoed = confirm === false;
+    const consented = !vetoed && confirm === true;
+    const requestId = presentRequestId(params.request_id) ?? derivedKey(
+      "search-auto",
+      // Passed as an OBJECT: derivedKey canonicalizes recursively, so nested
+      // property order (example_lead, filters) can never fork the key. Fields
+      // with a documented backend default are canonicalized TO that default,
+      // so an approval that omits one and a retry that passes it explicitly
+      // derive the same key rather than launching a second paid,
+      // novelty-claiming job.
+      {
+        query: params.query ?? null,
+        example_lead: params.example_lead ?? null,
+        // Sector/location lists are unordered sets to the backend — sort
+        // them so a reordered retry still dedupes.
+        filters: canonicalOptionalObject(sortFilterLists(normalizeSearchFilters(params.filters))),
+        count: params.count ?? null,
+        qualify: params.qualify === true,
+        min_ai_score: params.min_ai_score ?? 0,
+        contact_titles: canonicalLabelSet(params.contact_titles),
+        title_gate: params.title_gate ?? ((params.contact_titles?.length ?? 0) > 0 ? "prefer" : null),
+        channels: canonicalSet(params.channels),
+        // Sorted so ordering alone never forks the key, but PRESENT — a
+        // top-up differing only by exclude_lead_ids is a different approved
+        // search, and hashing it the same would return the first job as a
+        // duplicate with the exclusions never applied.
+        exclude_lead_ids: canonicalIdSet(params.exclude_lead_ids),
+        novelty: params.novelty ?? "org",
+        max_cost: params.max_cost ?? null,
+        // Documented backend default is min(3n,150), so an omitted cap is
+        // canonicalized TO it — same principle as min_ai_score/novelty above.
+        // Otherwise an approval that omits the cap and a retry that passes the
+        // materialized default ask for identical work under different keys,
+        // and the retry escapes dedupe into a second paid, novelty-claiming
+        // job. An explicit non-default cap still hashes distinctly.
+        exploration_cap: params.exploration_cap ?? (typeof params.count === "number" && params.count > 0 ? Math.min(3 * params.count, 150) : null),
+        lang: params.lang ?? null
+      }
+    );
+    const body = compactBody({
+      query: params.query,
+      example_lead: params.example_lead,
+      filters: normalizeSearchFilters(params.filters),
+      count: params.count,
+      qualify,
+      min_ai_score: params.min_ai_score,
+      contact_titles: params.contact_titles,
+      title_gate: params.title_gate,
+      channels: params.channels,
+      // Wire the SAME list the cap guard counted and the idempotency key was
+      // derived from. Posting the raw array instead let a 600-entry list that
+      // dedupes to 400 clear the guard and still be refused by the backend.
+      // Kept undefined when absent so compactBody drops it rather than
+      // sending an empty array.
+      exclude_lead_ids: params.exclude_lead_ids ? canonicalIdSet(params.exclude_lead_ids) : void 0,
+      novelty: params.novelty,
+      max_cost: params.max_cost,
+      exploration_cap: params.exploration_cap,
+      request_id: requestId,
+      lang: params.lang,
+      dry_run: dryRun
+    });
+    if (dryRun === true) {
+      const forecast = await client.request("POST", "/mcp/search", body);
+      return {
+        dry_run: true,
+        ...forecast,
+        region: client.region
+      };
+    }
+    if (isPaid && !consented) {
+      const forecast = vetoed ? null : await client.request("POST", "/mcp/search", {
+        ...body,
+        dry_run: true
+      });
+      return {
+        mode: "needs_confirmation",
+        submitted: false,
+        vetoed,
+        paid_because: [
+          buysQualification ? "qualify: true (~94 cost_cents per candidate EXAMINED)" : null,
+          buysChannels ? `channels requested: ${params.channels.join(", ")}` : null
+        ].filter(Boolean),
+        quote: forecast,
+        estimated_cost: forecast?.estimated_cost ?? null,
+        items_requested: forecast?.items_requested ?? null,
+        hint: vetoed ? "confirm:false vetoed the spend \u2014 nothing was submitted. Re-call with confirm:true to proceed, or drop qualify/channels for a free search." : "Show the user this worst-case quote and get an explicit go-ahead, then re-call with confirm:true. For a free search instead: omit qualify and channels.",
+        region: client.region
+      };
+    }
+    const submit = await client.request("POST", "/mcp/search", body, { preSendSignal: ctx?.signal });
+    const mocked = mockedSubmitPreview(submit, "leadbay_find_new_leads", client.region);
+    if (mocked)
+      return mocked;
+    const waitSeconds = clampWaitSeconds(params.wait_seconds, DEFAULT_WAIT_SECONDS);
+    const snapshot = await snapshotAfterSubmit(client, submit.job_id, waitSeconds, ctx, params.count);
+    const done = TERMINAL_JOB_STATES.has(snapshot.job.state);
+    const { leads, skipped } = splitItems(snapshot);
+    return {
+      job_id: submit.job_id,
+      request_id: requestId,
+      duplicate_submit: submit.duplicate ?? false,
+      state: snapshot.job.state,
+      done,
+      summary: {
+        // Named items_requested (not `requested`) to match qualify_leads and
+        // the shared renderer, which reads summary.items_requested for the
+        // "delivered X of the Y asked" clause.
+        items_requested: submit.items_requested ?? params.count,
+        delivered: snapshot.funnel.delivered ?? 0,
+        delivered_callable: snapshot.funnel.delivered_callable ?? 0,
+        delivered_title_only: snapshot.funnel.delivered_title_only ?? 0,
+        degraded: snapshot.funnel.degraded ?? 0,
+        stop_reason: snapshot.funnel.stop_reason ?? null
+      },
+      funnel: snapshot.funnel,
+      leads,
+      skipped,
+      items_truncated: snapshot.items_truncated ?? false,
+      // Top-level, not only inside next_poll: on a TERMINAL job that truncated,
+      // next_poll used to be null, so the rendering rule telling the agent to
+      // fetch the rest with `since: next_since` named a cursor the response did
+      // not contain. The rows are paid for; the way to reach them cannot be
+      // conditional on the job still running.
+      next_since: snapshot.next_since ?? null,
+      cost: snapshot.cost,
+      estimated_cost: submit.estimated_cost,
+      explain: snapshot.explain,
+      still_running: !done,
+      // A finished job can still owe rows: truncation means the drain stopped
+      // early, so there is a follow-up action even when done is true. It is a
+      // page fetch, not a wait, hence suggested_wait_seconds 0.
+      next_poll: done && !(snapshot.items_truncated ?? false) ? null : {
+        tool: "leadbay_lead_job_status",
+        job_id: submit.job_id,
+        // Hand the cursor forward so the follow-up poll continues
+        // INCREMENTALLY instead of re-reading (and re-rendering) the
+        // rows already delivered in this response.
+        since: snapshot.next_since ?? null,
+        suggested_wait_seconds: done ? 0 : 60
+      },
+      region: client.region
+    };
+  }
+};
+
+// ../core/dist/composite/qualify-leads.js
+var DEFAULT_WAIT_SECONDS2 = 45;
+function normalizeLeadRefs(refs) {
+  if (!Array.isArray(refs))
+    return refs;
+  return refs.map((ref) => {
+    if (typeof ref !== "string")
+      return ref;
+    const value = ref.trim();
+    if (!value)
+      return ref;
+    if (isUuidShaped(value))
+      return { lead_id: value };
+    return normalizeDomain(value) ? { website: value } : { name: value };
+  });
+}
+var LEAD_REF_FIELDS = [
+  "lead_id",
+  "website",
+  "name",
+  "location",
+  "contact_id"
+];
+function rejectMalformedLeadRefs(refs) {
+  if (!Array.isArray(refs))
+    return;
+  const bad = [];
+  refs.forEach((ref, i) => {
+    if (ref === null || typeof ref !== "object" || Array.isArray(ref)) {
+      bad.push(`${i} (not an object)`);
+      return;
+    }
+    for (const field of LEAD_REF_FIELDS) {
+      const value = ref[field];
+      if (value !== void 0 && typeof value !== "string") {
+        bad.push(`${i}.${field} (${value === null ? "null" : typeof value})`);
+      }
+    }
+  });
+  if (bad.length === 0)
+    return;
+  throw {
+    error: true,
+    code: "INVALID_LEAD_REF",
+    message: `lead_refs has ${bad.length} invalid entr${bad.length === 1 ? "y" : "ies"}: ${bad.join(", ")}.`,
+    hint: "Each ref is an object whose fields are STRINGS \u2014 {lead_id} | {website} | {name, location?} | {contact_id}. A bare string is accepted and reshaped; null, numbers, arrays and non-string field values are not. Fix or drop those entries and re-call."
+  };
+}
+function text(value) {
+  if (typeof value !== "string")
+    return null;
+  const v = value.trim().toLowerCase();
+  return v ? v : null;
+}
+function derivedRequestId(params) {
+  const refs = canonicalSet((params.lead_refs ?? []).map((r) => {
+    const website = text(r.website);
+    return [
+      // UUIDs are case-insensitive to the backend, so an uppercase id and
+      // its lowercase form are the same lead and must share a key.
+      normalizeUuid(r.lead_id),
+      normalizeUuid(r.contact_id),
+      // Normalize the website the SAME way the resolver does, so a pasted
+      // "https://Acme.com/" and a retry's "acme.com" resolve to one company
+      // AND to one key. Fall back to the trimmed/lowercased raw value when
+      // it is not domain-shaped, rather than dropping the field.
+      website ? normalizeDomain(website) ?? website : null,
+      text(r.name),
+      text(r.location)
+    ];
+  }));
+  const shape = {
+    refs,
+    // The WHOLE selector, not just the job id: qualifying the first 50 of a
+    // delivery job and then the next 50 are different batches, and collapsing
+    // them to one key would make the second submit look like a duplicate and
+    // leave those refs unqualified.
+    prior: [
+      // UUID-folded like the refs above: the backend resolves the same
+      // delivery job regardless of casing, so casing alone must not fork
+      // the key and re-run a paid batch.
+      normalizeUuid(params.prior_deliveries?.job_id),
+      params.prior_deliveries?.since ?? null,
+      params.prior_deliveries?.limit ?? null
+    ],
+    // Canonicalize to the value the BACKEND will apply, so an approval that
+    // omits a field and a retry that passes that field's documented default
+    // derive the same key instead of launching a second paid job.
+    qualify: params.qualify !== false,
+    channels: canonicalSet(params.channels),
+    contact_titles: canonicalLabelSet(params.contact_titles),
+    // Same canonicalization as the search path: with contact_titles present
+    // the backend applies `prefer` when the field is omitted, so an approval
+    // that omits it and a retry that passes the materialized default describe
+    // identical work. Hashing the omission as null forked the key and let the
+    // retry escape dedupe into a second paid qualification / channel purchase.
+    title_gate: params.title_gate ?? ((params.contact_titles?.length ?? 0) > 0 ? "prefer" : null),
+    // The cap is part of the approval: raising it after a stop_reason:max_cost
+    // is a NEW approved run, and must not dedupe onto the capped job.
+    max_cost: params.max_cost ?? null,
+    // Same for the output language — re-running the batch in another language
+    // must not return the earlier job with evidence in the previous one.
+    lang: params.lang ?? null
+  };
+  return derivedKey("qualify-auto", shape);
+}
+var qualifyLeads = {
+  name: "leadbay_qualify_leads",
+  annotations: {
+    title: "Qualify + get the right contact on known leads",
+    readOnlyHint: false,
+    // Spends real money (fresh qualification, and email/phone reveals when
+    // channels are requested), same as bulk_qualify_leads / enrich-titles.
+    // Hosts and approval layers key their prompts off this flag, so a paid
+    // job submitter must not advertise itself as harmless.
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true
+  },
+  write: true,
+  description: leadbay_qualify_leads,
+  inputSchema: {
+    type: "object",
+    properties: {
+      lead_refs: {
+        type: "array",
+        description: "Companies to qualify (max 500). Each ref needs at least one identifying field. Duplicate lead_ids collapse into one item.",
+        items: {
+          type: "object",
+          properties: {
+            lead_id: { type: "string", description: "Leadbay lead UUID." },
+            website: { type: "string" },
+            name: { type: "string" },
+            location: {
+              type: "string",
+              description: "Disambiguates name-only refs (city/region)."
+            },
+            contact_id: {
+              type: "string",
+              description: "Stable lead_contact id from a prior result \u2014 enrichment then targets EXACTLY this person, never a re-match."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      prior_deliveries: {
+        type: "object",
+        description: "Selector expanding the org's past MCP deliveries into refs \u2014 billed leads stay re-readable after result expiry. Combine with lead_refs or use alone.",
+        properties: {
+          job_id: { type: "string" },
+          since: { type: "string", description: "ISO instant lower bound." },
+          limit: { type: "number" }
+        },
+        additionalProperties: false
+      },
+      qualify: {
+        type: "boolean",
+        description: "Fresh AI qualification (default true; ~94 cost_cents per lead needing fresh research+scoring, cache-free when a fresh dossier exists). Owned disqualified leads come back WITH their negative evidence."
+      },
+      contact_titles: {
+        type: "array",
+        items: { type: "string" },
+        description: "Wanted decision-maker titles (max 10), matched semantically."
+      },
+      title_gate: {
+        type: "string",
+        enum: ["strict", "prefer"],
+        description: "strict = only items with a matching known contact deliver a contact; prefer = matched first, rest flagged."
+      },
+      channels: {
+        type: "array",
+        items: { type: "string", enum: ["email", "phone"] },
+        description: "Channels to PURCHASE (email 25c, phone 250c, success-only, already-owned values are free). Empty = free identity tier."
+      },
+      max_cost: {
+        type: "number",
+        description: "Spend cap in cost_cents (plan-tier default when unset)."
+      },
+      request_id: {
+        type: "string",
+        description: "Recommended idempotency key \u2014 REUSE the same value when retrying the same batch so a retry returns the SAME job instead of re-spending."
+      },
+      lang: { type: "string", description: "Output language (default: user's language)." },
+      confirm: {
+        type: "boolean",
+        description: "Explicit spend decision for the PAID work (fresh qualification and/or channel purchases). true = the user approved the quote, go ahead. false = a veto (returns mode:'needs_confirmation', spends nothing). Omitted on a paid call \u2192 the tool withholds the submit and returns a free quote to show the user first. A fully FREE call (qualify:false and no channels) needs no confirm."
+      },
+      dry_run: {
+        type: "boolean",
+        description: "Validate + worst-case cost + quota forecast. No job, no spend."
+      },
+      wait_seconds: {
+        type: "number",
+        description: "How long to poll before returning (default 45, max 180, 0 = submit + one snapshot). Large or research-heavy batches can take minutes \u2014 the result then carries still_running:true and the job_id for leadbay_lead_job_status."
+      }
+    },
+    additionalProperties: false
+  },
+  execute: async (client, params, ctx) => {
+    params = coerceArrayParams(params, [
+      "lead_refs",
+      "contact_titles",
+      "channels"
+    ]);
+    params = { ...params, lead_refs: normalizeLeadRefs(params.lead_refs) };
+    rejectMalformedLeadRefs(params.lead_refs);
+    rejectOversizedLeadRefs(params.lead_refs);
+    const qualify = readSpendFlag(params.qualify, "qualify");
+    const dryRun = readSpendFlag(params.dry_run, "dry_run");
+    const confirm = readSpendFlag(params.confirm, "confirm");
+    params = { ...params, qualify, dry_run: dryRun, confirm };
+    const buysChannels = (params.channels?.length ?? 0) > 0;
+    const buysQualification = qualify !== false;
+    const isPaid = buysQualification || buysChannels;
+    const vetoed = confirm === false;
+    const consented = !vetoed && confirm === true;
+    const requestId = presentRequestId(params.request_id) ?? (isPaid ? derivedRequestId(params) : void 0);
+    const body = compactBody({
+      lead_refs: params.lead_refs,
+      prior_deliveries: params.prior_deliveries,
+      qualify,
+      contact_titles: params.contact_titles,
+      title_gate: params.title_gate,
+      channels: params.channels,
+      max_cost: params.max_cost,
+      request_id: requestId,
+      lang: params.lang,
+      dry_run: dryRun
+    });
+    if (dryRun === true) {
+      const forecast = await client.request("POST", "/mcp/qualify", body);
+      return { dry_run: true, ...forecast, region: client.region };
+    }
+    if (isPaid && !consented) {
+      const forecast = vetoed ? null : await client.request("POST", "/mcp/qualify", {
+        ...body,
+        dry_run: true
+      });
+      return {
+        mode: "needs_confirmation",
+        submitted: false,
+        vetoed,
+        paid_because: [
+          buysQualification ? "qualify is on (backend default is true \u2014 pass qualify:false to keep it free)" : null,
+          buysChannels ? `channels requested: ${params.channels.join(", ")}` : null
+        ].filter(Boolean),
+        quote: forecast,
+        estimated_cost: forecast?.estimated_cost ?? null,
+        items_requested: forecast?.items_requested ?? null,
+        hint: vetoed ? "confirm:false vetoed the spend \u2014 nothing was submitted. Re-call with confirm:true to proceed, or qualify:false with no channels for a free pass." : "Show the user this worst-case quote and get an explicit go-ahead, then re-call with confirm:true. For a free pass instead: qualify:false and no channels.",
+        region: client.region
+      };
+    }
+    const submit = await client.request("POST", "/mcp/qualify", body, { preSendSignal: ctx?.signal });
+    const mocked = mockedSubmitPreview(submit, "leadbay_qualify_leads", client.region);
+    if (mocked)
+      return mocked;
+    const waitSeconds = clampWaitSeconds(params.wait_seconds, DEFAULT_WAIT_SECONDS2);
+    const snapshot = await snapshotAfterSubmit(client, submit.job_id, waitSeconds, ctx, submit.items_requested);
+    const done = TERMINAL_JOB_STATES.has(snapshot.job.state);
+    const indexed = submit.duplicate ?? false ? remapInputIndexes(snapshot.items, params.lead_refs) : { items: snapshot.items, remapped: true };
+    const view = { ...snapshot, items: indexed.items };
+    return {
+      job_id: submit.job_id,
+      // Echo the key actually sent, so a retry can reuse it verbatim.
+      request_id: requestId ?? null,
+      duplicate_submit: submit.duplicate ?? false,
+      state: snapshot.job.state,
+      done,
+      summary: {
+        refs_submitted: params.lead_refs?.length ?? 0,
+        items_requested: submit.items_requested,
+        delivered: snapshot.funnel.delivered ?? 0,
+        delivered_callable: snapshot.funnel.delivered_callable ?? 0,
+        degraded: snapshot.funnel.degraded ?? 0,
+        resolved: snapshot.funnel.resolved ?? null,
+        not_in_universe: snapshot.funnel.not_in_universe ?? null,
+        stop_reason: snapshot.funnel.stop_reason ?? null
+      },
+      funnel: snapshot.funnel,
+      // Per-item outcomes in input order where known (ref.input_indexes maps
+      // back to the caller's lead_refs positions). Items carry the full
+      // QualifiedLead payload when delivered/degraded, and an honest
+      // status_reason (not_in_universe, low_confidence_identity, ...) when
+      // skipped — a skip is an ANSWER about that ref, not an error.
+      items: view.items,
+      // On a duplicate submit whose indexes could not be re-pointed at this
+      // caller's refs, input_indexes are null rather than stale — match items
+      // by `ref.requested_as` / `lead_id` instead.
+      input_indexes_remapped: submit.duplicate ?? false ? indexed.remapped : null,
+      // ...and the same outcomes pre-split, because the shared
+      // rendering/lead-delivery-table contract this tool's description
+      // mandates reads deliveries from `leads[]` and skips from `skipped[]`.
+      // Returning only `items` left an agent following the RENDER block with
+      // two empty tables; the sibling tools (find_new_leads, lead_job_status)
+      // both split. `items` stays for input-order per-ref mapping.
+      ...splitItems(view),
+      items_truncated: snapshot.items_truncated ?? false,
+      // Top-level, not only inside next_poll: a TERMINAL job that truncated had
+      // next_poll null, so the rendering rule pointing at `since: next_since`
+      // named a cursor the response did not carry.
+      next_since: snapshot.next_since ?? null,
+      cost: snapshot.cost,
+      estimated_cost: submit.estimated_cost,
+      explain: snapshot.explain,
+      still_running: !done,
+      // A finished job can still owe rows: truncation means the drain stopped
+      // early, so there is a follow-up action even when done is true.
+      next_poll: done && !(snapshot.items_truncated ?? false) ? null : {
+        tool: "leadbay_lead_job_status",
+        job_id: submit.job_id,
+        // Hand the cursor forward so the follow-up poll continues
+        // INCREMENTALLY instead of re-reading (and re-rendering) the
+        // rows already delivered in this response.
+        since: snapshot.next_since ?? null,
+        suggested_wait_seconds: done ? 0 : 60
+      },
+      region: client.region
+    };
+  }
+};
+
+// ../core/dist/composite/lead-job-status.js
+var leadJobStatus = {
+  name: "leadbay_lead_job_status",
+  annotations: {
+    title: "Poll a lead-delivery job",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  description: leadbay_lead_job_status,
+  inputSchema: {
+    type: "object",
+    properties: {
+      job_id: {
+        type: "string",
+        description: "The job_id returned by leadbay_find_new_leads or leadbay_qualify_leads."
+      },
+      since: {
+        type: "string",
+        description: "Opaque cursor from a previous poll's next_since \u2014 returns only items emitted after it. Omit for the full snapshot."
+      },
+      limit: {
+        type: "number",
+        description: "Items per page, 1-100 (default 100; pages are auto-collected)."
+      },
+      wait_seconds: {
+        type: "number",
+        description: "0 (default) = instant snapshot. >0 = keep polling up to this many seconds until the job is terminal \u2014 use ~60 when the user asked to wait for results."
+      }
+    },
+    required: ["job_id"],
+    additionalProperties: false
+  },
+  execute: async (client, params, ctx) => {
+    const waitSeconds = clampWaitSeconds(params.wait_seconds, 0);
+    const snapshot = waitSeconds > 0 ? await waitForJob(client, params.job_id, waitSeconds, ctx, void 0, params.since, params.limit) : await collectJobSnapshot(client, params.job_id, params.since, params.limit, ctx?.signal);
+    const done = TERMINAL_JOB_STATES.has(snapshot.job.state);
+    const { leads, skipped } = splitItems(snapshot);
+    return {
+      job_id: params.job_id,
+      state: snapshot.job.state,
+      done,
+      funnel: snapshot.funnel,
+      leads,
+      skipped,
+      // Surfaced so the renderer never presents a partial page set as the whole
+      // result: `leads` is a prefix, and next_since resumes it.
+      items_truncated: snapshot.items_truncated ?? false,
+      next_since: snapshot.next_since ?? null,
+      cost: snapshot.cost,
+      explain: snapshot.explain,
+      still_running: !done,
+      // Truncation leaves rows unread even on a finished job, so the follow-up
+      // action survives `done` — same rule as the two submit tools.
+      next_poll: done && !(snapshot.items_truncated ?? false) ? null : {
+        tool: "leadbay_lead_job_status",
+        job_id: params.job_id,
+        // Same incremental handoff as the submit tools — following
+        // next_poll without the cursor re-reads the rows just returned.
+        since: snapshot.next_since ?? null,
+        suggested_wait_seconds: done ? 0 : 60
+      },
+      region: client.region
+    };
+  }
+};
+
+// ../core/dist/composite/extend-lens.js
+function httpStatus(err) {
+  return err?._meta?.http_status;
+}
+async function readExtraRefillQuota(client) {
+  try {
+    const me = await client.resolveMe();
+    const quota = await client.request("GET", `/organizations/${me.organization.id}/quota_status`);
+    const isRefill = (r) => r.resource_type?.toUpperCase() === "LENS_EXTRA_REFILL";
+    const entry = quota.org?.resources?.find(isRefill) ?? quota.user?.resources?.find(isRefill);
+    return {
+      count: entry?.count ?? null,
+      resets_at: entry?.resets_at ?? null
+    };
+  } catch {
+    return { count: null, resets_at: null };
+  }
+}
+async function readAvailablePool(client, lensId) {
+  try {
+    const preview = await client.request("GET", `/lenses/${lensId}/extra_refill_preview`);
+    return typeof preview?.available_count === "number" ? preview.available_count : null;
+  } catch {
+    return null;
+  }
+}
+async function readLensLeadTotal(client, lensId) {
+  try {
+    const page = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=1&page=0`);
+    return typeof page?.pagination?.total === "number" ? page.pagination.total : null;
+  } catch {
+    return null;
+  }
+}
+function noCandidatesReason(held, shape) {
+  const { geoSentence, ...extras } = shape;
+  const futile = " Extending again is futile \u2014 a refill on a lens with an empty candidate pool reports queued, consumes no quota and delivers nothing.";
+  if (held === 0) {
+    return {
+      code: "audience_too_narrow",
+      retryable: false,
+      message: "This lens holds no leads and has none left to add: its criteria intersect to nothing." + geoSentence + futile + " Tell the user which criteria are in play and offer to widen the audience (leadbay_adjust_audience).",
+      ...extras
+    };
   }
   if (held !== null) {
     return {
@@ -23506,8 +25994,8 @@ var sendFeedback = {
     }
   },
   execute: async (client, params, ctx) => {
-    const text = typeof params.message === "string" ? params.message.trim() : "";
-    if (!text) {
+    const text2 = typeof params.message === "string" ? params.message.trim() : "";
+    if (!text2) {
       return {
         error: true,
         code: "BAD_INPUT",
@@ -23515,7 +26003,7 @@ var sendFeedback = {
         hint: "Ask the user what they'd like to tell the Leadbay team, then call again with their words in `message`."
       };
     }
-    const message = text.length > MESSAGE_MAX2 ? `${text.slice(0, MESSAGE_MAX2 - 1)}\u2026` : text;
+    const message = text2.length > MESSAGE_MAX2 ? `${text2.slice(0, MESSAGE_MAX2 - 1)}\u2026` : text2;
     if (!ctx?.sendFeedback) {
       return {
         sent: false,
@@ -23646,6 +26134,13 @@ granularTools.forEach((t) => {
   t.advanced = true;
 });
 var compositeReadTools = [
+  // Poll surface for the MCP-first lead-delivery jobs (find_new_leads /
+  // qualify_leads). Read-only snapshot of a backend-owned job. The backend
+  // routes (`POST /1.6/mcp/search`, `POST /1.6/mcp/qualify`,
+  // `GET /1.6/mcp/jobs/{id}`) shipped to production in backend v3.22.0
+  // (2026-08-22) and were verified live on both regions, so the opt-in
+  // LEADBAY_MCP_LEAD_DELIVERY flag that held these three back is gone.
+  leadJobStatus,
   pullLeads,
   pullFollowups,
   followupsMap,
@@ -23708,6 +26203,11 @@ var compositeReadTools = [
   // leadbay_new_lens / leadbay_adjust_audience). Without it the agent can only
   // probe sectors by trial-and-error or ask the user to read the web UI.
   listSectors,
+  // listLocations, same rationale on the geography axis. The delivery tools
+  // reject an unresolvable filters.locations with a 400 naming the value and
+  // send the agent here to look up the real admin area — a recovery path that
+  // only works if the lookup is reachable without LEADBAY_MCP_ADVANCED=1.
+  listLocations,
   // Billing / top-up tools — granular-shaped but ALWAYS exposed because
   // they're the canonical recovery path from a QUOTA_EXCEEDED wall. If
   // they were gated behind LEADBAY_MCP_ADVANCED=1 the agent would
@@ -23737,7 +26237,21 @@ var compositeReadTools = [
   // tools/) so it carries no _triggered_by mandate for a kit fetch.
   artifactKit
 ];
+var mcpFirstDeliveryTools = [
+  // Write-tier: submits create server-side jobs that can spend money
+  // (qualification research, channel purchase) and claim novelty in the
+  // org's delivery ledger — same posture as the other spending composites.
+  // The FREE tier (qualify:false, channels:[]) is the default ask, and a paid
+  // call is withheld in code until `confirm: true`.
+  findNewLeads,
+  qualifyLeads
+];
+var mcpFirstDeliveryAllTools = [
+  ...mcpFirstDeliveryTools,
+  leadJobStatus
+];
 var compositeWriteTools = [
+  ...mcpFirstDeliveryTools,
   bulkQualifyLeads,
   enrichTitles,
   adjustAudience,
@@ -24598,8 +27112,22 @@ function buildProtocolPrimitivesParagraph(has) {
     "import_and_qualify",
     "enrich_titles",
     "bulk_enrich_status",
-    "qualify_status"
+    "qualify_status",
+    // The MCP-first delivery jobs block-poll for 45s by default and up to
+    // 180s. Without a progressToken ctx.progress is absent, so the call looks
+    // frozen for minutes — the exact case this paragraph exists to prevent.
+    // `.filter(has)` keeps the iter-12 invariant: a deployment without the
+    // delivery flag never sees them named.
+    "find_new_leads",
+    "qualify_leads",
+    "lead_job_status"
   ].filter((n) => has(`leadbay_${n}`));
+  const legacyRunners = longRunners.filter(
+    (n) => !["find_new_leads", "qualify_leads", "lead_job_status"].includes(n)
+  );
+  const deliveryRunners = longRunners.filter(
+    (n) => ["find_new_leads", "qualify_leads", "lead_job_status"].includes(n)
+  );
   const elicitTools = [
     "refine_prompt clarifications",
     "report_outreach.user_confirmed"
@@ -24618,9 +27146,20 @@ function buildProtocolPrimitivesParagraph(has) {
       "(1) `notifications/progress` \u2014 when you pass `_meta.progressToken` on a tools/call, long-running composites stream per-unit-of-work progress (none of the long-runners are currently exposed in this configuration)."
     );
   }
-  if (longRunners.length > 0) {
+  if (legacyRunners.length > 0 || deliveryRunners.length > 0) {
+    const clauses = [];
+    if (legacyRunners.length > 0) {
+      clauses.push(
+        "On " + legacyRunners.map((n) => `leadbay_${n}`).join(", ") + " the job itself keeps running on the backend; poll its notification_id / importIds later to pick it up."
+      );
+    }
+    if (deliveryRunners.length > 0) {
+      clauses.push(
+        "On " + deliveryRunners.map((n) => `leadbay_${n}`).join(", ") + " the job is BACKEND-owned and likewise keeps running. Any work already paid for still completes; poll `leadbay_lead_job_status` with the `job_id` later to collect it."
+      );
+    }
     parts.push(
-      "(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."
+      "(2) `notifications/cancelled` \u2014 when the user clicks Cancel in the host UI, the polling loop exits within \u22642 seconds. " + clauses.join(" ")
     );
   } else {
     parts.push(
@@ -24827,11 +27366,16 @@ function buildServer(client, opts = {}) {
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: toolsListPayload([...toolByName.values()])
   }));
+  const promptGate = { includeWrite: Boolean(opts.includeWrite) };
   server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-    prompts: listPrompts()
+    prompts: listPrompts(promptGate)
   }));
   server.setRequestHandler(GetPromptRequestSchema, async (req) => {
-    return getPrompt(req.params.name, req.params.arguments ?? {});
+    return getPrompt(
+      req.params.name,
+      req.params.arguments ?? {},
+      promptGate
+    );
   });
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({
     resources: listResources()
@@ -25568,7 +28112,7 @@ function parseWriteEnv(env = process.env) {
 }
 
 // src/http-server.ts
-var VERSION = true ? "0.36.0" : "0.0.0-dev";
+var VERSION = true ? "0.37.0" : "0.0.0-dev";
 var PORT = Number(process.env.PORT ?? 8080);
 var HOST = process.env.HOST ?? "0.0.0.0";
 var logger = {