@leadbay/mcp 0.24.0 → 0.24.1

package/dist/http-server.js

@@ -408,6 +408,7 @@ Pick 2\u20133 items below based on what was actually observed in the response. T
 | Observation                                                | Suggest                                                      | Calls                                                  |
 |------------------------------------------------------------|--------------------------------------------------------------|--------------------------------------------------------|
 | \u2265 5 leads returned (any batch)                             | "Build an interactive lead triage board for this batch"      | emit antArtifact from data in hand (do NOT re-call leadbay_pull_leads) |
+| \u2265 1 lead returned (any batch)                              | "Enrich top leads" (reveal decision-maker email/phone on the top leads) | leadbay_enrich_titles({ leadIds: shown leads[].id, lensId }) \u2014 scope to the leads JUST shown; OMIT \`titles\` so it runs the no-spend discovery preview. Confirm titles + channels, then re-call with titles + confirm to launch |
 | \`has_more == true\`                                         | "Pull the next page (page N+1 of M)"                         | leadbay_pull_leads(page = current + 1, lensId = pinned)|
 | \u2265 3 rows have \`qualification_summary.answered == 0\`        | "Deepen AI qualification on the rows without \u2756 caps"         | leadbay_bulk_qualify_leads(leadIds=[\u2026])                |
 | User points at a single row                                | "Research [Company] in depth"                                | leadbay_research_lead_by_id(leadId)                    |
@@ -1038,30 +1039,18 @@ GATE \u2014 DEFER TO TOOL RENDERING. When you call a Leadbay composite that ship
 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.
 
 
-Research the company with domain '{{arg:domain}}' for me using Leadbay.
+Research the company name or domain '{{arg:domain}}' for me using Leadbay.
 
-# PHASE 1 \u2014 IMPORT + QUALIFY
-Call \`leadbay_import_and_qualify\` with \`domains=[{domain:'{{arg:domain}}'}]\`. This imports the lead AND runs AI qualification in one call. If the response indicates \`quota_blocked\` or \`still_running\`, say so explicitly. Render the import status using the canonical terse single-record summary (never an enumeration of every imported lead):
+# PHASE 1 \u2014 RESOLVE + DEEP DIVE
+Call \`leadbay_research_lead_by_name_fuzzy\` with
+\`companyName:'{{arg:domain}}'\`. Omit \`lensId\`: the default search deliberately
+covers the user's visible Discover, Monitor, and Activate corpus, including
+other lenses and leads outside the active lens's first page. The composite
+resolves the lead and returns the full deep-research payload in one call.
 
-## RENDERING \u2014 import result summary (single-record, terse)
-
-The response carries either a completed result or an async handle. Render a brief summary; do NOT enumerate every imported lead.
-
-**Header \u2014 single line, choose by status:**
-
-- Completed: \`"\u2713 Import complete \u2014 N leads imported \xB7 M failed \xB7 P resolved-with-ambiguity"\`
-- Running: \`"\u23F3 Import running \u2014 handle_id <id>; poll leadbay_import_status"\`
-- Pending qualification (\`leadbay_import_and_qualify\`): \`"\u2713 Imported N leads \xB7 qualifying M of them \u2014 qualify_id <id>"\`
-
-**When failures or ambiguous rows are non-empty**, follow the header with a small bulleted list (\u2264 5 items): \`<row identifier or domain> \xB7 <reason>\`. Then \`"*+N more \u2014 leadbay_import_status for full detail*"\`.
-
-**When the user's request implied a downstream use** ("import then prep outreach for them"), emit \`Imported leadIds: <up to 5 ids, then '+N more'>\` \u2014 just the ids. Let the next composite render the leads.
-
-Defer the full list of imported leads to \`leadbay_pull_leads\` or \`leadbay_research_lead_by_id\` in NEXT STEPS.
-
-
-# PHASE 2 \u2014 DEEP DIVE
-When the import resolves, call \`leadbay_research_lead_by_id\` on the new leadId. Render the result using the canonical single-record card layout \u2014 detect MODE A (Discovery) since the user asked to "research" a domain rather than to prepare outreach:
+Render the result using the canonical single-record card layout \u2014 detect MODE A
+(Discovery) since the user asked to research a company rather than prepare
+outreach:
 
 ## RENDERING \u2014 single-record research card, mode-adaptive
 
@@ -1133,10 +1122,16 @@ When the response carries \`social_urls\` (the post-fix multi-platform URL block
 
 
 
+# PHASE 2 \u2014 NOT FOUND
+If the resolver returns \`LEAD_NOT_FOUND\`, say that the existing visible corpus
+was searched. **Do NOT call \`leadbay_import_and_qualify\` automatically.** Offer
+to import and qualify the company as a separate, explicit next step; only call
+it after the user agrees.
+
 # PHASE 3 \u2014 SUMMARY
 Place a 2\u20133 sentence summary ABOVE the card with:
 - Who is this company (1 sentence)
-- Their fit (cite specific \`qualification_answers\` from the qualification response)
+- Their fit (cite specific qualification answers or signals from the research response)
 - Which contact would I email first (one short clause \u2014 the card's contacts table carries the rest)
 
 The card itself handles the signal callouts (\`\u{1F4C8} business signals\`, \`\u{1F4A1} prospecting clues\`). Do NOT re-narrate signals in prose above the card \u2014 that's what the card sections are for. Be honest about uncertainty: if any field is missing from tool responses, say "not surfaced by qualification" rather than guessing.
@@ -1312,7 +1307,7 @@ should I follow up on" to "I'll send via lemlist".
 `, "arguments": [], "expected_calls": ["leadbay_account_status", "leadbay_pull_leads", "leadbay_pull_followups", "leadbay_research_lead_by_id", "leadbay_research_lead_by_name_fuzzy", "leadbay_prepare_outreach", "leadbay_report_outreach", "leadbay_set_pushback", "leadbay_remove_pushback", "leadbay_bulk_qualify_leads", "leadbay_enrich_titles", "leadbay_import_leads", "leadbay_add_note", "leadbay_adjust_audience"], "failure_modes": ['Drives outreach without asking the user "how did it go?" afterwards \u2014 leaving prospecting_actions and epilogue_status stale', 'Says "epilogue" in user-facing dialogue instead of "outcome"', 'Says "Monitor" in user-facing dialogue instead of "follow-ups"', 'Treats a "not now / next quarter" reply as a note instead of routing through the pushback mechanism', "Drafts outreach in a generic format when the user has a connected sequencer (lemlist, Outreach.io, etc.) that has its own idiom", "Re-pulls leads without passing the captured lensId, allowing a backend lens shift to discard prior work", "Skips the STOP byproduct in any multi-step workflow it triggers", "Calls leadbay_pull_leads (Discover wishlist) for a follow-up query, or leadbay_pull_followups (Monitor view) for a discovery query \u2014 the two entry points read from different backend tables; the right orchestrators are leadbay_daily_check_in (discovery) and leadbay_followup_check_in (follow-up)"] },
   leadbay_qualify_top_n: { "name": "leadbay_qualify_top_n", "short_description": "Bulk-qualify the top N un-qualified leads in the active lens. Uses\nleadbay_bulk_qualify_leads with a sensible default budget.\n", "arguments": [{ "name": "count", "description": "How many leads to qualify (default 10, max 25). Higher counts may take 5+ minutes.", "required": false }], "expected_calls": ["leadbay_bulk_qualify_leads", "leadbay_qualify_status", "leadbay_pull_leads", "leadbay_research_lead_by_id"], "failure_modes": ["Picks a count larger than the user asked for (or larger than the max 25)", "Glosses over still-running leads in the summary instead of naming them", "Recommends a lead from the existing qualified pool instead of one from this batch's actual results", 'Replaces the canonical pull_leads table with prose when rendering the newly-qualified batch (the per-tool RENDERING block is the structural contract; "standouts" commentary sits above it)', "Expands the qualify-status sentence into a card or table instead of the one-line status-inline render"] },
   leadbay_refine_audience: { "name": "leadbay_refine_audience", "short_description": "Refine the kind of leads Leadbay surfaces beyond firmographics, with a\nfree-text instruction. Handles the clarification round-trip if the new\nprompt is ambiguous.\n", "arguments": [{ "name": "instruction", "description": "The refinement (e.g. 'focus on hospitals running their own IT'). Set to plain English.", "required": true }], "expected_calls": ["leadbay_refine_prompt", "leadbay_account_status"], "failure_modes": ["Calls leadbay_answer_clarification on the user's behalf instead of surfacing the clarification verbatim", "Glosses over the clarification options instead of presenting them as offered", "Promises immediate effect when status='applied' actually triggers an async intelligence recompute"] },
-  leadbay_research_a_domain: { "name": "leadbay_research_a_domain", "short_description": "Import a company by domain and run deep qualification + research in one\npass. Use when a colleague mentions a name and you want everything Leadbay\nknows about it.\n", "arguments": [{ "name": "domain", "description": "The company's primary domain (e.g. 'acme.com'). Protocol/path are stripped.", "required": true }], "expected_calls": ["leadbay_import_and_qualify", "leadbay_research_lead_by_id"], "failure_modes": ["Fabricates qualification answers not present in any tool response", "Reports certainty about fit when qualification didn't actually run (e.g. quota_blocked)", "Skips the research step after import completes", "Renders the research_lead_by_id result as a freeform narrative instead of the canonical research-company-card layout (the card with header score bar, pill row, signal sections, contacts table is the structural contract; commentary belongs ABOVE or BELOW it)", "Enumerates every imported lead in prose instead of the terse single-record summary from the import-result rendering snippet"] },
+  leadbay_research_a_domain: { "name": "leadbay_research_a_domain", "short_description": "Resolve a company by name or domain across the user's visible Discover,\nMonitor, and Activate corpus, then return everything Leadbay knows about it.\n", "arguments": [{ "name": "domain", "description": "Company name or domain (for example 'Acme Corporation' or 'acme.com'). The legacy argument key remains `domain` for client compatibility.", "required": true }], "expected_calls": ["leadbay_research_lead_by_name_fuzzy"], "failure_modes": ["Fabricates qualification answers not present in any tool response", "Calls leadbay_import_and_qualify before searching the existing visible corpus", "Treats the active lens as the entire search universe when the user did not request a lens scope", "Imports a missing company without the user's explicit permission", "Renders the research result as a freeform narrative instead of the canonical research-company-card layout (the card with header score bar, pill row, signal sections, contacts table is the structural contract; commentary belongs ABOVE or BELOW it)"] },
   leadbay_setup_team_prospecting: { "name": "leadbay_setup_team_prospecting", "short_description": "Manager-led prospecting setup: conversationally turn a natural-language\naudience ask into a Leadbay lens, validate the candidate leads, and\npersist them as one or more named campaigns the rep(s) can work\nthrough. Closes #3630 US3 end-to-end (within the current\ncreator-scoped campaign visibility model).\n", "arguments": [{ "name": "audience", "description": "Natural-language audience description (e.g. 'plumbing companies with 10-50 employees in Seine-Maritime'). The lens-creation step (`leadbay_refine_prompt` \u2192 `leadbay_create_lens`) interprets it.", "required": true }, { "name": "rep_split", "description": "Optional: how to split the validated leads into per-rep campaigns. Free text \u2014 e.g. 'split by city' or 'one campaign per rep: John gets Tulsa, Sarah gets OKC'.", "required": false }], "expected_calls": ["leadbay_refine_prompt", "leadbay_create_lens", "leadbay_promote_lens", "leadbay_pull_leads", "leadbay_research_lead_by_id", "leadbay_create_campaign", "leadbay_add_leads_to_campaign"], "failure_modes": ["Skips the validation step \u2014 creates a campaign of unvetted leads from a freshly-created lens without giving the manager a chance to drop weak fits", "Creates ONE campaign for all reps without asking about the split \u2014 the user explicitly mentioned per-rep distribution and the prompt should honor it", "Pretends the backend supports cross-user assignment \u2014 campaigns are owned by the caller (creator-scoped). Surface this honestly instead of fabricating an assignment model", "Asks ALL clarifying questions inline before tool calls \u2014 instead, run the lens refinement loop with `leadbay_refine_prompt` which handles the clarification protocol natively"] },
   leadbay_work_campaign: { "name": "leadbay_work_campaign", "short_description": "Work a campaign as a real outreach session: pick the campaign,\nassess what the user has (phones / emails / coords), then PROPOSE\nthe right session mode (call sheet, email sheet, enrich titles\nfirst, map). After they pick, render \u2014 and as they dictate\noutcomes per lead, record both note + epilogue via\n`leadbay_report_outreach` in one round trip.\n", "arguments": [{ "name": "campaign", "description": "Campaign name (fuzzy match against your own campaigns) or campaign UUID. Omit to list and pick interactively.", "required": false }, { "name": "mode", "description": "Optional: skip the readiness-assessment proposal and jump directly into 'call_sheet' / 'email_sheet' / 'map' / 'enrich_first'. Omit (recommended) and let the prompt propose based on the data.", "required": false }], "expected_calls": ["leadbay_list_campaigns", "leadbay_campaign_call_sheet", "leadbay_enrich_titles", "leadbay_report_outreach"], "failure_modes": ["Renders the call sheet immediately without proposing the right mode \u2014 if 60% of leads have no contacts, calling is futile; enrich first. Always assess `readiness` first.", "Auto-renders the map widget without asking \u2014 maps are intrusive when the user just wants to scroll a list. Map mode is a proposed option, not a default.", "Proposes map mode after the user has previously said they don't like maps \u2014 check conversation memory before adding 'View on a map' to the options list.", "Calls `leadbay_campaign_progression` instead of `leadbay_campaign_call_sheet` \u2014 progression has counts but no phones / LinkedIn / call-ready data; the user can't actually dial from progression rows.", "Renders contacts WITHOUT making the phone number a `[bare](tel:URL)` link \u2014 on mobile that breaks one-tap calling, which is the whole point of the cheat sheet.", "Records outreach WITHOUT epilogue_status \u2014 leaves the lead's pipeline state unchanged; the rep then sees the same lead surfaced again next session.", "Records outreach WITHOUT verification \u2014 verification.source/ref is REQUIRED. For calls, pass `{source: 'user_confirmed', ref: <user's exact words>}`.", "Loops through ALL leads in a 50-lead campaign before recording any outreach \u2014 the call-then-record loop must be per-lead, not batched."] }
 };
@@ -1328,7 +1323,7 @@ var PROMPT_CATALOG_BULLETS = {
   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.`,
   leadbay_refine_audience: `- \`leadbay_refine_audience\` (required args: instruction): Refine the kind of leads Leadbay surfaces beyond firmographics, with a free-text instruction. Handles the clarification round-trip if the new prompt is ambiguous.`,
-  leadbay_research_a_domain: `- \`leadbay_research_a_domain\` (required args: domain): Import a company by domain and run deep qualification + research in one pass. Use when a colleague mentions a name and you want everything Leadbay knows about it.`,
+  leadbay_research_a_domain: `- \`leadbay_research_a_domain\` (required args: domain): Resolve a company by name or domain across the user's visible Discover, Monitor, and Activate corpus, then return everything Leadbay knows about it.`,
   leadbay_setup_team_prospecting: `- \`leadbay_setup_team_prospecting\` (required args: audience; optional args: rep_split): Manager-led prospecting setup: conversationally turn a natural-language audience ask into a Leadbay lens, validate the candidate leads, and persist them as one or more named campaigns the rep(s) can work through. Closes #3630 US3 end-to-end (within the current creator-scoped campaign visibility model).`,
   leadbay_work_campaign: `- \`leadbay_work_campaign\` (optional args: campaign, mode): Work a campaign as a real outreach session: pick the campaign, assess what the user has (phones / emails / coords), then PROPOSE the right session mode (call sheet, email sheet, enrich titles first, map). After they pick, render \u2014 and as they dictate outcomes per lead, record both note + epilogue via \`leadbay_report_outreach\` in one round trip.`
 };
@@ -1363,7 +1358,7 @@ var CATALOG = [
     arguments: [
       {
         name: "domain",
-        description: "The company's primary domain (e.g. 'acme.com'). Protocol/path are stripped.",
+        description: "Company name or domain (for example 'Acme Corporation' or 'acme.com'). The legacy argument key remains `domain` for client compatibility.",
         required: true
       }
     ],
@@ -9333,6 +9328,7 @@ Pick 2\u20133 items below based on what was actually observed in the response. T
 | Observation                                                | Suggest                                                      | Calls                                                  |
 |------------------------------------------------------------|--------------------------------------------------------------|--------------------------------------------------------|
 | \u2265 5 leads returned (any batch)                             | "Build an interactive lead triage board for this batch"      | emit antArtifact from data in hand (do NOT re-call leadbay_pull_leads) |
+| \u2265 1 lead returned (any batch)                              | "Enrich top leads" (reveal decision-maker email/phone on the top leads) | leadbay_enrich_titles({ leadIds: shown leads[].id, lensId }) \u2014 scope to the leads JUST shown; OMIT \`titles\` so it runs the no-spend discovery preview. Confirm titles + channels, then re-call with titles + confirm to launch |
 | \`has_more == true\`                                         | "Pull the next page (page N+1 of M)"                         | leadbay_pull_leads(page = current + 1, lensId = pinned)|
 | \u2265 3 rows have \`qualification_summary.answered == 0\`        | "Deepen AI qualification on the rows without \u2756 caps"         | leadbay_bulk_qualify_leads(leadIds=[\u2026])                |
 | User points at a single row                                | "Research [Company] in depth"                                | leadbay_research_lead_by_id(leadId)                    |
@@ -9779,30 +9775,23 @@ Examples that should NOT invoke this tool (sound similar, route elsewhere):
 
 ---
 
-Thin wrapper around **leadbay_research_lead_by_id**. Accepts a \`companyName\`,
-fuzzy-matches it against the top 50 of the active (or supplied) lens's
-wishlist, picks the highest-scoring substring hit, and delegates the actual
-research to \`leadbay_research_lead_by_id\`. Returns the **same payload shape**
-as \`_by_id\`, with two additions on \`_meta\`:
+Resolves \`companyName\` across visible Discover, Monitor, and Activate leads,
+then delegates to **leadbay_research_lead_by_id**. Supplying \`lensId\`
+deliberately restricts the backend search to that lens. The result matches
+\`_by_id\`, plus:
 
-- \`_meta.resolved_from\`: \`"companyName"\` (so the agent knows the entry point).
-- \`_meta.resolved_query\`: the original \`companyName\` string.
-- \`_meta.match_candidates[]\`: up to 4 next-best substring matches as
-  \`{leadId, name, score}\` \u2014 surface these when ambiguity is plausible so the
-  user can redirect.
+- \`_meta.resolved_from\`: \`"companyName"\`
+- \`_meta.resolved_query\`: the original query
+- \`_meta.match_candidates[]\`: up to 4 \`{leadId, name, score}\` alternatives
 
-On zero matches, throws \`LEAD_NOT_FOUND\` with a \`nearest_names[]\` payload (the
-top 5 by score from the lens, regardless of substring) so the agent can offer
-"did you mean\u2026" disambiguation.
+\`LEAD_NOT_FOUND\` identifies whether the complete visible corpus, an explicit
+lens, or only a degraded active-lens fallback was searched.
 
-WHEN TO USE: when the user references a company by
-name and you don't yet have its \`lead_id\`. If \`_meta.match_candidates\` is
-non-empty, offer the next-best matches in NEXT STEPS so the user can correct
-a wrong fuzzy hit.
+WHEN TO USE: for a company/domain/contact reference
+without a \`lead_id\`. Offer \`_meta.match_candidates\` when present.
 
-WHEN NOT TO USE: when you already have the UUID \u2014 use
-leadbay_research_lead_by_id directly. This wrapper costs one extra
-\`discoverLeads\` round-trip; skipping it when you can is cheaper.
+WHEN NOT TO USE: with a UUID; call
+leadbay_research_lead_by_id directly.
 
 ---
 
@@ -9943,9 +9932,9 @@ out?"\`
 
 When \`_meta.match_candidates\` is non-empty, prepend one extra NEXT STEPS row:
 
-| Observation                                            | Suggest                                                              | Calls                                                                  |
-|--------------------------------------------------------|----------------------------------------------------------------------|------------------------------------------------------------------------|
-| \`_meta.match_candidates\` non-empty                     | "Did you mean **&lt;next-best.name&gt;**?"                                | leadbay_research_lead_by_id(leadId=&lt;next-best.leadId&gt;)                |
+| Observation | Suggest | Calls |
+|---|---|---|
+| Alternatives found | "Did you mean **&lt;next-best.name&gt;**?" | leadbay_research_lead_by_id(leadId=&lt;next-best.leadId&gt;) |
 `;
 var leadbay_resolve_import_rows = `Resolve messy CSV-shaped lead rows against Leadbay before file import. The tool sends each row's available identity signals to \`POST /leads/resolve\`, returns matched lead IDs or ambiguous candidate IDs, and produces \`records_for_import\` plus a SAFE identity-only \`mappings_for_import\` starting point for leadbay_import_leads / leadbay_import_and_qualify. This tool deliberately does not try to understand every CSV dialect; the agent should inspect the file, derive clean helper columns when useful, pass explicit \`identity_mappings\`, and build the final CRM mapping from \`mapping_guidance\`.
 
@@ -15350,6 +15339,11 @@ function buildPullLeadsNextSteps(args) {
     description: "Build an interactive lead triage board to sort and filter this batch.",
     kind: "build_artifact"
   });
+  options.push({
+    label: "Enrich top leads",
+    description: "Enrich the top leads",
+    kind: "enrich_top_leads"
+  });
   options.push({
     label: "Deepen qualification",
     description: "Run deeper AI qualification on these leads.",
@@ -15435,7 +15429,7 @@ var pullLeads = {
       },
       next_steps: {
         type: ["object", "null"],
-        description: "Ready-made NEXT STEPS for the host's choice widget. Each option has a SHORT `label` (\u22645 words, fits AskUserQuestion's label cap on Claude cowork/Claude Code) and a full `description`. For AskUserQuestion (cowork/Claude Code) pass each option as {label, description}. For ask_user_input_v0 (Claude chat/ChatGPT, string-only options) use the `description` as the option string. Use these VERBATIM, in order \u2014 do NOT re-derive, reword, or render as prose when a widget tool exists. options[0] is the artifact offer (build the lead triage board) whenever the batch is non-empty. When the batch is empty but the lens is still computing (computing_wishlist/computing_scores true), this carries a 'Re-pull in ~30s' option (kind:repull_computing) plus 'Refine audience' \u2014 render the widget so the user waits rather than seeing 'no leads.' null only when the batch is empty AND nothing is computing (a genuinely empty / over-narrow lens).",
+        description: "Ready-made NEXT STEPS for the host's choice widget. Each option has a SHORT `label` (\u22645 words, fits AskUserQuestion's label cap on Claude cowork/Claude Code) and a full `description`. For AskUserQuestion (cowork/Claude Code) pass each option as {label, description}. For ask_user_input_v0 (Claude chat/ChatGPT, string-only options) use the `description` as the option string. Use these VERBATIM, in order \u2014 do NOT re-derive, reword, or render as prose when a widget tool exists. options[0] is the artifact offer (build the lead triage board) whenever the batch is non-empty; options[1] is the enrich offer (kind:enrich_top_leads \u2014 route it to leadbay_enrich_titles scoped to the leadIds JUST shown (pass leads[].id + the pinned lens.id) with NO titles, so it runs the no-spend discovery preview; quota is only spent after the user picks titles + confirms channels on a follow-up call). When the batch is empty but the lens is still computing (computing_wishlist/computing_scores true), this carries a 'Re-pull in ~30s' option (kind:repull_computing) plus 'Refine audience' \u2014 render the widget so the user waits rather than seeing 'no leads.' null only when the batch is empty AND nothing is computing (a genuinely empty / over-narrow lens).",
         properties: {
           question: { type: "string" },
           options: {
@@ -17224,6 +17218,41 @@ function rankSubstringMatches(needle, candidates) {
   });
   return hits;
 }
+function parseLensId(value) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function suggestionName(suggestion) {
+  const companyName = (suggestion.company_name ?? suggestion.companyName)?.trim();
+  return companyName || suggestion.text.trim();
+}
+function suggestionLeadId(suggestion) {
+  return suggestion.lead_id ?? suggestion.leadId;
+}
+function isLeadbayError(error) {
+  return typeof error === "object" && error !== null && error.error === true && typeof error.code === "string" && typeof error.message === "string" && typeof error.hint === "string";
+}
+async function resolveWithinLens(client, query, lensId) {
+  const results = await client.request("GET", `/lenses/${lensId}/leads/wishlist?q=${encodeURIComponent(query)}&count=50&page=0&contacts=false`);
+  return results.items.map((lead) => ({
+    id: lead.id,
+    name: lead.name,
+    score: lead.score,
+    lensId
+  }));
+}
+async function resolveAcrossVisibleCorpus(client, query) {
+  const suggestions = await client.request("GET", `/search/suggest?q=${encodeURIComponent(query)}`);
+  return suggestions.map((suggestion) => {
+    const id = suggestionLeadId(suggestion);
+    return {
+      id: id ?? "",
+      name: suggestionName(suggestion),
+      score: null,
+      lensId: parseLensId(suggestion.lens_id ?? suggestion.lensId)
+    };
+  }).filter((suggestion) => suggestion.id !== "" && suggestion.name !== "");
+}
 var researchLeadByNameFuzzy = {
   name: "leadbay_research_lead_by_name_fuzzy",
   annotations: {
@@ -17239,11 +17268,11 @@ var researchLeadByNameFuzzy = {
     properties: {
       companyName: {
         type: "string",
-        description: "Company name to look up. Substring fuzzy-match against the top 50 of the active lens's wishlist; ties broken by descending lead score."
+        description: "Company name, domain, or contact name to resolve across visible Leadbay leads in Discover, Monitor, and Activate."
       },
       lensId: {
         type: "number",
-        description: "Lens id (escape hatch \u2014 normally omit; auto-resolves to the active lens)"
+        description: "Optional strict scope. When supplied, search only this lens's wishlist; normally omit to search all visible Leadbay leads."
       },
       concise: {
         type: "boolean",
@@ -17268,18 +17297,34 @@ var researchLeadByNameFuzzy = {
     additionalProperties: true
   },
   execute: async (client, params, ctx) => {
-    if (!params.companyName || typeof params.companyName !== "string") {
+    if (!params.companyName || typeof params.companyName !== "string" || params.companyName.trim() === "") {
       throw client.makeError("INVALID_PARAMS", "companyName is required", "Pass the company name as a string. If you already have the lead UUID, call leadbay_research_lead_by_id directly.");
     }
-    const lensId = params.lensId ?? await client.resolveDefaultLens();
-    const results = await discoverLeads.execute(client, { lensId, count: 50, page: 0 }, ctx);
-    const allLeads = results.leads;
-    const ranked = rankSubstringMatches(params.companyName, allLeads);
+    const query = params.companyName.trim();
+    let ranked;
+    let lensId = params.lensId;
+    let usedActiveLensFallback = false;
+    if (lensId !== void 0) {
+      ranked = await resolveWithinLens(client, query, lensId);
+    } else {
+      try {
+        ranked = await resolveAcrossVisibleCorpus(client, query);
+      } catch (error) {
+        if (isLeadbayError(error))
+          throw error;
+        lensId = await client.resolveDefaultLens();
+        usedActiveLensFallback = true;
+        ctx?.logger?.warn?.("Cross-tab company search was unavailable; falling back to the active lens for this lookup.");
+        ranked = rankSubstringMatches(query, await resolveWithinLens(client, query, lensId));
+      }
+    }
     if (ranked.length === 0) {
-      const nearestNames = [...allLeads].sort((a, b) => (b.score ?? -Infinity) - (a.score ?? -Infinity)).slice(0, 5).map((l) => ({ leadId: l.id, name: l.name, score: l.score }));
-      throw client.makeError("LEAD_NOT_FOUND", `No lead matching "${params.companyName}" in the current lens (top-50 wishlist)`, `Call leadbay_pull_leads to see what's available. Top-scoring leads currently in this lens: ${nearestNames.map((n) => n.name).join(", ")}.`);
+      const scope = usedActiveLensFallback ? `in active lens ${lensId}; cross-tab search was unavailable` : params.lensId === void 0 ? "across your visible Leadbay leads" : `in lens ${params.lensId}`;
+      const hint = usedActiveLensFallback ? `Only active lens ${lensId} was checked because cross-tab search was unavailable. Retry later before concluding the company is missing or offering to import it.` : params.lensId === void 0 ? "Search checks company names, domains, and contact names across Discover, Monitor, and Activate. Confirm the spelling or domain, or add/import the company first." : "This lookup was intentionally restricted to the supplied lens. Omit lensId to search visible leads across Discover, Monitor, and Activate.";
+      throw client.makeError("LEAD_NOT_FOUND", `No lead matching "${query}" ${scope}`, hint);
     }
     const [primary, ...rest] = ranked;
+    lensId = primary.lensId ?? lensId ?? await client.resolveDefaultLens();
     const candidates = rest.slice(0, 4).map((m) => ({
       leadId: m.id,
       name: m.name,
@@ -17292,7 +17337,7 @@ var researchLeadByNameFuzzy = {
       response_format: params.response_format,
       _resolved: {
         from: "companyName",
-        query: params.companyName,
+        query,
         candidates
       }
     }, ctx);
@@ -23154,18 +23199,41 @@ var BUILTIN_WIDGETS_PARAGRAPH = 'Prefer host-native widgets over inline markdown
 // src/telemetry.ts
 import { PostHog } from "posthog-node";
 import * as Sentry from "@sentry/node";
+
+// src/telemetry-constants.ts
+var EMBEDDED_POSTHOG_KEY = "phc_N9SnA7OULuAlXReQJZ0Y3rPI4eC0mJLpMRbzgqamhHR";
+var EMBEDDED_POSTHOG_HOST = "https://eu.i.posthog.com";
+var EMBEDDED_SENTRY_DSN = "https://301f1c433433b76132956ed5415bea19@o4505874436849664.ingest.us.sentry.io/4511419984248832";
+
+// src/telemetry-events.ts
+var EV_TOOL_CALL = "mcp tool called";
+var EV_QUOTA_HIT = "mcp quota hit";
+var EV_TOPUP_LINK = "mcp topup link created";
+var EV_STARTUP = "mcp startup";
+var EV_MCP_UPDATE_CHECK = "mcp update check";
+var EV_MCP_UPDATE_PROMPTED = "mcp update prompted";
+var EV_MCP_UPDATE_INSTALL_CLICKED = "mcp update install_clicked";
+var EV_MCP_UPDATE_DISMISSED = "mcp update dismissed";
+var EV_MCP_VERSION_UPDATED = "mcp version updated";
+var EV_AGENT_MEMORY_CAPTURED = "agent_memory_captured";
+var EV_AGENT_MEMORY_RECALLED = "agent_memory_recalled";
+var EV_AGENT_MEMORY_PRUNED = "agent_memory_pruned";
+var EV_FRICTION_REPORTED = "mcp friction reported";
+var EV_COMPOSITE_CALL = "mcp composite call";
+
+// src/telemetry.ts
 var NOOP_TELEMETRY = {
   identify: async () => {
   },
-  captureToolCall: () => {
+  captureToolCall: (_props, _identity) => {
   },
-  captureCompositeCall: () => {
+  captureCompositeCall: (_props, _identity) => {
   },
-  captureQuotaHit: () => {
+  captureQuotaHit: (_props, _identity) => {
   },
-  captureTopupLink: () => {
+  captureTopupLink: (_props, _identity) => {
   },
-  captureStartup: () => {
+  captureStartup: (_props, _identity) => {
   },
   captureAgentMemoryCaptured: () => {
   },
@@ -23191,6 +23259,320 @@ var NOOP_TELEMETRY = {
   shutdown: async () => {
   }
 };
+function parseTelemetryEnv(raw) {
+  if (raw === void 0 || raw === "") return true;
+  const v = raw.trim().toLowerCase();
+  if (v === "false" || v === "0" || v === "no" || v === "off") return false;
+  return true;
+}
+function initTelemetry(opts) {
+  if (!parseTelemetryEnv(process.env.LEADBAY_TELEMETRY_ENABLED)) return NOOP_TELEMETRY;
+  if (process.env.NODE_ENV === "test") return NOOP_TELEMETRY;
+  const posthogKey = process.env.LEADBAY_POSTHOG_KEY ?? EMBEDDED_POSTHOG_KEY;
+  const sentryDsn = process.env.LEADBAY_SENTRY_DSN ?? EMBEDDED_SENTRY_DSN;
+  if (!posthogKey && !sentryDsn) return NOOP_TELEMETRY;
+  const { version, logger: logger2 } = opts;
+  const flushAt = opts.flushAt ?? 20;
+  const flushInterval = opts.flushInterval ?? 1e4;
+  const environment = process.env.LEADBAY_ENV ?? (version.includes("-dev.") ? "dev" : "production");
+  let posthog = null;
+  let sentryReady = false;
+  let initError = null;
+  try {
+    if (posthogKey) {
+      posthog = new PostHog(posthogKey, {
+        host: process.env.LEADBAY_POSTHOG_HOST ?? EMBEDDED_POSTHOG_HOST,
+        flushAt,
+        flushInterval,
+        disableGeoip: false
+      });
+    }
+  } catch (err) {
+    initError = err;
+    posthog = null;
+  }
+  try {
+    if (sentryDsn) {
+      Sentry.init({
+        dsn: sentryDsn,
+        release: `@leadbay/mcp@${version}`,
+        environment,
+        tracesSampleRate: 0,
+        profilesSampleRate: 0,
+        defaultIntegrations: false,
+        integrations: [Sentry.httpIntegration()],
+        sendDefaultPii: false,
+        // Tag every captured event with the surface so Sentry views can
+        // split MCP issues from web-app issues without per-call work.
+        // Version is also encoded in `release` above, but a dedicated
+        // `mcp_version` tag is filterable from Sentry's issue list without
+        // expanding the release dropdown — load-bearing when triaging
+        // "errors at reinstall on @0.13" vs older clients still on @0.11.
+        initialScope: {
+          tags: {
+            source: "mcp",
+            mcp_version: version,
+            node_version: process.versions.node,
+            platform: process.platform
+          }
+        }
+      });
+      sentryReady = true;
+    }
+  } catch (err) {
+    initError = initError ?? err;
+    sentryReady = false;
+  }
+  if (initError) {
+    logger2?.warn?.(`telemetry init failed: ${initError.message ?? initError}`);
+  }
+  if (!posthog && !sentryReady) return NOOP_TELEMETRY;
+  let me = null;
+  let identityPromise = null;
+  const pendingEvents = [];
+  let region = "unknown";
+  const baseProps = () => ({
+    // Always tag MCP-originated events so PostHog dashboards can split
+    // MCP usage from the web app and any future surfaces. The value
+    // ("mcp") is the canonical source identifier — match it in any
+    // PostHog filter or insight that should isolate the MCP surface.
+    source: "mcp",
+    mcp_version: version,
+    node_version: process.versions.node,
+    platform: process.platform,
+    region
+  });
+  const distinctIdFor = () => {
+    if (me?.email) return me.email;
+    if (me?.id) return `mcp:user-${me.id}`;
+    return "mcp:unknown";
+  };
+  const groupsFor = () => {
+    return me?.organization?.id ? { organization: me.organization.id } : void 0;
+  };
+  const doCapture = (event, properties, identity) => {
+    if (!posthog) return;
+    try {
+      const props = identity?.region ? { ...baseProps(), region: identity.region, ...properties } : { ...baseProps(), ...properties };
+      posthog.capture({
+        distinctId: identity ? identity.distinctId : distinctIdFor(),
+        event,
+        properties: props,
+        groups: identity ? identity.groups : groupsFor()
+      });
+    } catch (err) {
+      logger2?.warn?.(`posthog capture failed: ${err?.message ?? err}`);
+    }
+  };
+  const emit = (event, properties, identity) => {
+    if (!posthog) return;
+    if (identity) {
+      doCapture(event, properties, identity);
+      return;
+    }
+    if (!me) {
+      pendingEvents.push({ event, properties });
+      return;
+    }
+    doCapture(event, properties);
+  };
+  const flushPending = () => {
+    if (!posthog || pendingEvents.length === 0) return;
+    const buf = pendingEvents.splice(0, pendingEvents.length);
+    for (const { event, properties } of buf) {
+      doCapture(event, properties);
+    }
+  };
+  return {
+    identify(client) {
+      if (identityPromise) return identityPromise;
+      region = client.region;
+      identityPromise = (async () => {
+        try {
+          const resolved = await client.resolveMe();
+          me = resolved;
+          if (posthog && resolved.email) {
+            try {
+              posthog.identify({
+                distinctId: resolved.email,
+                properties: {
+                  email: resolved.email,
+                  leadbay_id: resolved.id,
+                  leadbay_name: resolved.name,
+                  leadbay_organization: resolved.organization?.name,
+                  leadbay_organization_id: resolved.organization?.id
+                }
+              });
+            } catch (err) {
+              logger2?.warn?.(`posthog identify failed: ${err?.message ?? err}`);
+            }
+          }
+          if (sentryReady) {
+            try {
+              Sentry.setUser({
+                id: resolved.id,
+                email: resolved.email,
+                username: resolved.name
+              });
+            } catch (err) {
+              logger2?.warn?.(`sentry setUser failed: ${err?.message ?? err}`);
+            }
+          }
+          flushPending();
+        } catch (err) {
+          logger2?.warn?.(
+            `telemetry identify failed (${err?.message ?? err}); flushing events anonymously`
+          );
+          me = {
+            id: "unknown",
+            organization: { id: "unknown", name: "unknown" }
+          };
+          flushPending();
+        }
+      })();
+      return identityPromise;
+    },
+    captureToolCall(props, identity) {
+      emit(EV_TOOL_CALL, { ...props }, identity);
+    },
+    captureCompositeCall(props, identity) {
+      emit(EV_COMPOSITE_CALL, { ...props }, identity);
+    },
+    captureQuotaHit(props, identity) {
+      emit(EV_QUOTA_HIT, { ...props }, identity);
+    },
+    captureTopupLink(props, identity) {
+      emit(EV_TOPUP_LINK, { ...props }, identity);
+    },
+    captureStartup(props, identity) {
+      emit(EV_STARTUP, { ...props }, identity);
+    },
+    captureAgentMemoryCaptured(props, identity) {
+      emit(EV_AGENT_MEMORY_CAPTURED, { ...props }, identity);
+    },
+    captureAgentMemoryRecalled(props, identity) {
+      emit(EV_AGENT_MEMORY_RECALLED, { ...props }, identity);
+    },
+    captureAgentMemoryPruned(props, identity) {
+      emit(EV_AGENT_MEMORY_PRUNED, { ...props }, identity);
+    },
+    captureFrictionReported(props, identity) {
+      emit(EV_FRICTION_REPORTED, { ...props }, identity);
+    },
+    captureUpdateCheck(props) {
+      emit(EV_MCP_UPDATE_CHECK, { ...props });
+    },
+    captureUpdatePrompted(props) {
+      emit(EV_MCP_UPDATE_PROMPTED, { ...props });
+    },
+    captureUpdateInstallClicked(props) {
+      emit(EV_MCP_UPDATE_INSTALL_CLICKED, { ...props });
+    },
+    captureUpdateDismissed(props) {
+      emit(EV_MCP_UPDATE_DISMISSED, { ...props });
+    },
+    captureVersionUpdated(props) {
+      emit(EV_MCP_VERSION_UPDATED, { ...props });
+    },
+    captureException(err, ctx) {
+      if (!sentryReady) return;
+      try {
+        Sentry.withScope((scope) => {
+          scope.setTag("tool", ctx.tool);
+          if (ctx.code) scope.setTag("error_code", ctx.code);
+          if (ctx.endpoint) scope.setTag("endpoint", ctx.endpoint);
+          if (ctx.region) scope.setTag("region", ctx.region);
+          if (ctx.http_status !== void 0) {
+            scope.setTag("http_status", String(ctx.http_status));
+          }
+          if (ctx.source) scope.setTag("source", ctx.source);
+          if (me?.organization?.id) {
+            scope.setTag("organization", me.organization.id);
+          }
+          if (ctx.message) scope.setExtra("message", ctx.message);
+          if (ctx.hint) scope.setExtra("hint", ctx.hint);
+          if (ctx.triggered_by) scope.setExtra("triggered_by", ctx.triggered_by);
+          if (ctx.latency_ms !== void 0 && ctx.latency_ms !== null) {
+            scope.setExtra("latency_ms", ctx.latency_ms);
+          }
+          if (ctx.retry_after !== void 0 && ctx.retry_after !== null) {
+            scope.setExtra("retry_after", ctx.retry_after);
+          }
+          if (ctx.code && ctx.source === "business") {
+            scope.setFingerprint(["mcp", ctx.tool, ctx.code]);
+          }
+          Sentry.captureException(err);
+        });
+      } catch (e) {
+        logger2?.warn?.(`sentry captureException failed: ${e?.message ?? e}`);
+      }
+    },
+    async captureFeedback(message, opts2, identity) {
+      if (!sentryReady) return false;
+      const trimmed = (message ?? "").trim();
+      if (!trimmed) return false;
+      if (!identity && identityPromise) {
+        let waitTimer;
+        try {
+          await Promise.race([
+            identityPromise,
+            new Promise((resolve) => {
+              waitTimer = setTimeout(resolve, 2e3);
+            })
+          ]);
+        } catch {
+        } finally {
+          if (waitTimer) clearTimeout(waitTimer);
+        }
+      }
+      const fbName = identity?.name ?? me?.name;
+      const fbEmail = identity?.email ?? me?.email;
+      try {
+        Sentry.captureFeedback({
+          message: trimmed,
+          ...fbName ? { name: fbName } : {},
+          ...fbEmail ? { email: fbEmail } : {},
+          ...opts2?.associatedEventId ? { associatedEventId: opts2.associatedEventId } : {}
+        });
+        const flushed = await Sentry.flush(4e3);
+        if (!flushed) {
+          logger2?.warn?.("sentry feedback flush timed out (event may be buffered)");
+        }
+        return flushed;
+      } catch (e) {
+        logger2?.warn?.(`sentry captureFeedback failed: ${e?.message ?? e}`);
+        return false;
+      }
+    },
+    async shutdown() {
+      if (!me && identityPromise) {
+        let waitTimer;
+        try {
+          await Promise.race([
+            identityPromise,
+            new Promise((resolve) => {
+              waitTimer = setTimeout(resolve, 1500);
+            })
+          ]);
+        } catch {
+        } finally {
+          if (waitTimer) clearTimeout(waitTimer);
+        }
+      }
+      if (!me) {
+        me = {
+          id: "unknown",
+          organization: { id: "unknown", name: "unknown" }
+        };
+        flushPending();
+      }
+      const tasks = [];
+      if (posthog) tasks.push(posthog.shutdown(2e3).catch(() => void 0));
+      if (sentryReady) tasks.push(Sentry.close(2e3).catch(() => void 0));
+      await Promise.allSettled(tasks);
+    }
+  };
+}
 
 // src/update-check.ts
 var cachedInfo = null;
@@ -23838,7 +24220,7 @@ function buildServer(client, opts = {}) {
   });
   const DEBUG_RAW = process.env.LEADBAY_DEBUG ?? "";
   const DEBUG_ON = DEBUG_RAW === "1" || DEBUG_RAW.toLowerCase() === "true";
-  const telemetry = opts.telemetry ?? NOOP_TELEMETRY;
+  const telemetry2 = opts.telemetry ?? NOOP_TELEMETRY;
   const promptedVersionsThisSession = /* @__PURE__ */ new Set();
   const serverVersion = opts.version ?? "0.0.0-dev";
   const UPDATE_CHECK_DISABLED = process.env.LEADBAY_UPDATE_CHECK_DISABLED === "1";
@@ -23848,7 +24230,7 @@ function buildServer(client, opts = {}) {
     void checkForUpdate({
       currentVersion: serverVersion,
       stateStore: opts.updateStateStore,
-      telemetry,
+      telemetry: telemetry2,
       logger: opts.logger
     }).catch((err) => {
       opts.logger?.warn?.(
@@ -23898,7 +24280,7 @@ function buildServer(client, opts = {}) {
     }
     if (!alreadyPrompted) {
       promptedVersionsThisSession.add(info.latest_version);
-      telemetry.captureUpdatePrompted?.({
+      telemetry2.captureUpdatePrompted?.({
         current_version: serverVersion,
         latest_version: info.latest_version
       });
@@ -23945,7 +24327,7 @@ function buildServer(client, opts = {}) {
     if (typeof fr.category !== "string" || typeof fr.user_quote !== "string") {
       return;
     }
-    telemetry.captureFrictionReported({
+    telemetry2.captureFrictionReported({
       category: fr.category,
       user_quote: fr.user_quote,
       ...typeof fr.tool_called === "string" ? { tool_called: fr.tool_called } : {},
@@ -23957,7 +24339,7 @@ function buildServer(client, opts = {}) {
     if (!result || typeof result !== "object") return;
     const meta = result._meta ?? {};
     if (toolName === "leadbay_agent_memory_capture") {
-      telemetry.captureAgentMemoryCaptured({
+      telemetry2.captureAgentMemoryCaptured({
         source: result.captured?.source ?? meta.source,
         scope: result.captured?.scope ?? meta.scope,
         key: result.captured?.key,
@@ -23965,13 +24347,13 @@ function buildServer(client, opts = {}) {
         account_id_hash: meta.account_id_hash
       });
     } else if (toolName === "leadbay_agent_memory_recall") {
-      telemetry.captureAgentMemoryRecalled({
+      telemetry2.captureAgentMemoryRecalled({
         entries_returned: result.entries_returned,
         total_active: result.total_active,
         account_id_hash: meta.account_id_hash
       });
     } else if (toolName === "leadbay_agent_memory_review" && result.changed === true && (result.action === "retract" || result.action === "prune")) {
-      telemetry.captureAgentMemoryPruned({
+      telemetry2.captureAgentMemoryPruned({
         action: result.action,
         account_id_hash: meta.account_id_hash
       });
@@ -24058,7 +24440,7 @@ ${url}
         };
         const pendingText = formatErrorForLLM(envelope);
         const pendingDur = Date.now() - callStart;
-        telemetry.captureToolCall({
+        telemetry2.captureToolCall({
           tool: name,
           ok: false,
           duration_ms: pendingDur,
@@ -24087,7 +24469,7 @@ ${url}
         };
         const guardText = formatErrorForLLM(envelope);
         const guardDur = Date.now() - callStart;
-        telemetry.captureToolCall({
+        telemetry2.captureToolCall({
           tool: name,
           ok: false,
           duration_ms: guardDur,
@@ -24096,7 +24478,7 @@ ${url}
           error_code: envelope.code,
           triggered_by
         });
-        telemetry.captureCompositeCall({
+        telemetry2.captureCompositeCall({
           tool: name,
           last_prompt: triggered_by ?? "",
           ok: false,
@@ -24128,7 +24510,7 @@ ${url}
         // Route leadbay_send_feedback to Sentry's feedback inbox (same place
         // the web app's form lands). NOOP_TELEMETRY returns false, so the
         // tool reports honestly when telemetry is off.
-        sendFeedback: (message, fbOpts) => telemetry.captureFeedback(message, fbOpts)
+        sendFeedback: (message, fbOpts) => telemetry2.captureFeedback(message, fbOpts)
       });
       await maybeAttachUpdate(name, result);
       maybeAttachNotifications(result);
@@ -24137,13 +24519,13 @@ ${url}
         const envDur = Date.now() - callStart;
         const envCode = result.code ?? "Error";
         if (envCode === "QUOTA_EXCEEDED") {
-          telemetry.captureQuotaHit({
+          telemetry2.captureQuotaHit({
             tool: name,
             retry_after_s: result._meta?.retry_after,
             endpoint: result._meta?.endpoint
           });
         }
-        telemetry.captureToolCall({
+        telemetry2.captureToolCall({
           tool: name,
           ok: false,
           duration_ms: envDur,
@@ -24153,7 +24535,7 @@ ${url}
           triggered_by
         });
         if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry.captureCompositeCall({
+          telemetry2.captureCompositeCall({
             tool: name,
             last_prompt: triggered_by ?? "",
             ok: false,
@@ -24161,7 +24543,7 @@ ${url}
             error_code: envCode
           });
         }
-        telemetry.captureException(
+        telemetry2.captureException(
           result,
           buildBusinessCtx(name, result, triggered_by)
         );
@@ -24189,7 +24571,7 @@ ${url}
         }
         const mdDur = Date.now() - callStart;
         const mdBytes = env.markdown.length;
-        telemetry.captureToolCall({
+        telemetry2.captureToolCall({
           tool: name,
           ok: true,
           duration_ms: mdDur,
@@ -24198,7 +24580,7 @@ ${url}
           triggered_by
         });
         if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry.captureCompositeCall({
+          telemetry2.captureCompositeCall({
             tool: name,
             last_prompt: triggered_by ?? "",
             ok: true,
@@ -24208,7 +24590,7 @@ ${url}
         captureAgentMemoryTelemetry(name, env.structured);
         captureFrictionTelemetry(name, env.structured);
         if (name === "leadbay_create_topup_link" && typeof env.structured?.url === "string") {
-          telemetry.captureTopupLink({ tool: name });
+          telemetry2.captureTopupLink({ tool: name });
         }
         if (DEBUG_ON) {
           process.stderr.write(
@@ -24229,7 +24611,7 @@ ${url}
       const okText = response.content[0]?.text ?? "";
       const okBytes = typeof okText === "string" ? okText.length : 0;
       const okDur = Date.now() - callStart;
-      telemetry.captureToolCall({
+      telemetry2.captureToolCall({
         tool: name,
         ok: true,
         duration_ms: okDur,
@@ -24238,7 +24620,7 @@ ${url}
         triggered_by
       });
       if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-        telemetry.captureCompositeCall({
+        telemetry2.captureCompositeCall({
           tool: name,
           last_prompt: triggered_by ?? "",
           ok: true,
@@ -24248,7 +24630,7 @@ ${url}
       captureAgentMemoryTelemetry(name, result);
       captureFrictionTelemetry(name, result);
       if (name === "leadbay_create_topup_link" && typeof result?.url === "string") {
-        telemetry.captureTopupLink({ tool: name });
+        telemetry2.captureTopupLink({ tool: name });
       }
       if (DEBUG_ON) {
         process.stderr.write(
@@ -24263,14 +24645,14 @@ ${url}
       const code = err?.code ?? err?.name ?? "Error";
       if (isLeadbayBusinessError(err)) {
         if (err.code === "QUOTA_EXCEEDED") {
-          telemetry.captureQuotaHit({
+          telemetry2.captureQuotaHit({
             tool: name,
             retry_after_s: err._meta?.retry_after,
             endpoint: err._meta?.endpoint
           });
         }
         const httpStatus2 = err._meta?.http_status;
-        telemetry.captureToolCall({
+        telemetry2.captureToolCall({
           tool: name,
           ok: false,
           duration_ms: errDur,
@@ -24281,7 +24663,7 @@ ${url}
           triggered_by
         });
         if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry.captureCompositeCall({
+          telemetry2.captureCompositeCall({
             tool: name,
             last_prompt: triggered_by ?? "",
             ok: false,
@@ -24290,15 +24672,15 @@ ${url}
             ...typeof httpStatus2 === "number" ? { http_status: httpStatus2 } : {}
           });
         }
-        telemetry.captureException(err, buildBusinessCtx(name, err, triggered_by));
+        telemetry2.captureException(err, buildBusinessCtx(name, err, triggered_by));
       } else {
-        telemetry.captureException(err, {
+        telemetry2.captureException(err, {
           tool: name,
           source: "unexpected",
           message: typeof err?.message === "string" ? err.message : void 0,
           triggered_by
         });
-        telemetry.captureToolCall({
+        telemetry2.captureToolCall({
           tool: name,
           ok: false,
           duration_ms: errDur,
@@ -24308,7 +24690,7 @@ ${url}
           triggered_by
         });
         if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry.captureCompositeCall({
+          telemetry2.captureCompositeCall({
             tool: name,
             last_prompt: triggered_by ?? "",
             ok: false,
@@ -24358,7 +24740,7 @@ function makeBrokenClient(stubError, region) {
 
 // src/auth-http.ts
 async function resolveClientFromToken(token, opts = {}) {
-  const { region, baseUrl, logger } = opts;
+  const { region, baseUrl, logger: logger2 } = opts;
   if (!token || token.length === 0) {
     const fallbackRegion = region === "fr" ? "fr" : "us";
     return {
@@ -24380,10 +24762,10 @@ async function resolveClientFromToken(token, opts = {}) {
     if (region) config.region = region;
     return { client: createClient(config), authState: "ok" };
   }
-  logger?.info?.("hosted MCP: region unpinned, probing api-us + api-fr in parallel");
+  logger2?.info?.("hosted MCP: region unpinned, probing api-us + api-fr in parallel");
   const probe = async (r) => {
     const c = createClient({ token, region: r });
-    await c.request("GET", "/users/me");
+    await c.resolveMe();
     return c;
   };
   try {
@@ -24448,9 +24830,63 @@ function parseWriteEnv(env = process.env) {
 }
 
 // src/http-server.ts
-var VERSION = true ? "0.24.0" : "0.0.0-dev";
+var VERSION = true ? "0.24.1" : "0.0.0-dev";
 var PORT = Number(process.env.PORT ?? 8080);
 var HOST = process.env.HOST ?? "0.0.0.0";
+var logger = {
+  info: (m) => process.stderr.write(`[leadbay-mcp-http info] ${m}
+`),
+  warn: (m) => process.stderr.write(`[leadbay-mcp-http warn] ${m}
+`),
+  error: (m) => process.stderr.write(`[leadbay-mcp-http error] ${m}
+`)
+};
+var telemetry = initTelemetry({ version: VERSION, logger });
+var IDENTITY_RESOLVE_TIMEOUT_MS = 1500;
+async function resolveIdentity(client) {
+  const region = client.region;
+  try {
+    const me = await Promise.race([
+      client.resolveMe(),
+      new Promise(
+        (resolve) => setTimeout(() => resolve(null), IDENTITY_RESOLVE_TIMEOUT_MS)
+      )
+    ]);
+    if (!me) return { distinctId: "mcp:unknown", region };
+    const distinctId = me.email ?? (me.id ? `mcp:user-${me.id}` : "mcp:unknown");
+    return {
+      distinctId,
+      groups: me.organization?.id ? { organization: me.organization.id } : void 0,
+      region,
+      // name/email so leadbay_send_feedback attributes correctly on HTTP — the
+      // module-scoped `me` is never populated here (Codex P2).
+      ...me.name ? { name: me.name } : {},
+      ...me.email ? { email: me.email } : {}
+    };
+  } catch (err) {
+    logger.warn?.(`telemetry identity resolve failed: ${err?.message ?? err}`);
+    return { distinctId: "mcp:unknown", region };
+  }
+}
+function bindTelemetryIdentity(base, identity) {
+  return {
+    ...base,
+    captureToolCall: (p) => base.captureToolCall(p, identity),
+    captureCompositeCall: (p) => base.captureCompositeCall(p, identity),
+    captureQuotaHit: (p) => base.captureQuotaHit(p, identity),
+    captureTopupLink: (p) => base.captureTopupLink(p, identity),
+    captureStartup: (p) => base.captureStartup(p, identity),
+    captureAgentMemoryCaptured: (p) => base.captureAgentMemoryCaptured(p, identity),
+    captureAgentMemoryRecalled: (p) => base.captureAgentMemoryRecalled(p, identity),
+    captureAgentMemoryPruned: (p) => base.captureAgentMemoryPruned(p, identity),
+    captureFrictionReported: (p) => base.captureFrictionReported(p, identity),
+    captureFeedback: (message, opts) => base.captureFeedback(message, opts, identity),
+    identify: async () => {
+    },
+    shutdown: async () => {
+    }
+  };
+}
 var sseSessions = /* @__PURE__ */ new Map();
 var SSE_SESSION_TTL_MS = 30 * 60 * 1e3;
 setInterval(() => {
@@ -24470,10 +24906,16 @@ function extractBearer(authHeader) {
   const m = /^Bearer\s+(.+)$/i.exec(authHeader);
   return m ? m[1].trim() : void 0;
 }
-function buildServerFromClient(client) {
+function buildServerFromClient(client, requestTelemetry) {
   const includeWrite = parseWriteEnv();
   const includeAdvanced = process.env.LEADBAY_MCP_ADVANCED === "1";
-  return buildServer(client, { version: VERSION, includeWrite, includeAdvanced });
+  return buildServer(client, {
+    version: VERSION,
+    includeWrite,
+    includeAdvanced,
+    logger,
+    telemetry: requestTelemetry
+  });
 }
 var PRM_PREFIX = "/.well-known/oauth-protected-resource";
 var RESOURCE_PATHS = ["/mcp", "/fr/mcp", "/sse", "/fr/sse"];
@@ -24549,11 +24991,15 @@ async function handleStreamable(c, resourcePath) {
   const foreign = rejectForeignOrigin(c);
   if (foreign) return foreign;
   const token = extractBearer(c.req.header("authorization"));
-  const resolved = await resolveClientFromToken(token);
+  const resolved = await resolveClientFromToken(token, { logger });
   if (resolved.authState === "missing" || resolved.authState === "expired") {
     return sendChallenge(c, resourcePath, resolved.authState);
   }
-  const server = buildServerFromClient(resolved.client);
+  const identity = await resolveIdentity(resolved.client);
+  const server = buildServerFromClient(
+    resolved.client,
+    bindTelemetryIdentity(telemetry, identity)
+  );
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: void 0,
     // Return JSON responses instead of SSE so non-SSE clients (e.g. Codex) work.
@@ -24596,13 +25042,17 @@ async function handleSse(c, resourcePath) {
   const foreign = rejectForeignOrigin(c);
   if (foreign) return foreign;
   const token = extractBearer(c.req.header("authorization"));
-  const resolved = await resolveClientFromToken(token);
+  const resolved = await resolveClientFromToken(token, { logger });
   if (resolved.authState === "missing" || resolved.authState === "expired") {
     return sendChallenge(c, resourcePath, resolved.authState);
   }
+  const identity = await resolveIdentity(resolved.client);
   const env = c.env;
   const transport = new SSEServerTransport("/messages", env.outgoing);
-  const server = buildServerFromClient(resolved.client);
+  const server = buildServerFromClient(
+    resolved.client,
+    bindTelemetryIdentity(telemetry, identity)
+  );
   await server.connect(transport);
   const sessionId = transport.sessionId;
   sseSessions.set(sessionId, { transport, server, createdAt: Date.now() });
@@ -24649,8 +25099,23 @@ if (isEntrypoint) {
       `leadbay-mcp-http ${VERSION} listening on http://${info.address}:${info.port} (boot=${_boot})
 `
     );
+    telemetry.captureStartup(
+      { auth_state: "ok", region: "unknown" },
+      { distinctId: "mcp:http-server", region: "unknown" }
+    );
   });
+  const gracefulShutdown = async () => {
+    try {
+      await telemetry.shutdown();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.once("SIGTERM", () => void gracefulShutdown());
+  process.once("SIGINT", () => void gracefulShutdown());
 }
 export {
-  app
+  app,
+  bindTelemetryIdentity,
+  resolveIdentity
 };