@leadbay/mcp 0.24.1 → 0.25.0

package/dist/http-server.js

@@ -568,7 +568,7 @@ Build the final mappings yourself. Start from \`leadbay_resolve_import_rows.mapp
 
 # PHASE 5 \u2014 QUALIFY (optional) + REPORT
 
-Prefer \`leadbay_import_and_qualify\` when the user asks to qualify/research after import; otherwise use \`leadbay_import_leads\`. For large files or short client timeouts, pass \`wait_for_completion=false\` and poll \`leadbay_import_status\`. After import, qualify only lead IDs returned by the import; late website matches may appear later via \`import_status\`.
+Prefer \`leadbay_import_and_qualify\` when the user asks to qualify/research after import; otherwise use \`leadbay_import_leads\`. For large files or short client timeouts, pass \`wait_for_completion=false\` and poll \`leadbay_import_status\`. After import, qualify only lead IDs returned by the import. Rows that came back \`uncrawled\` are pending a background crawl (not failures); the leads Leadbay adds for them populate in the user's Leadbay account as the crawl completes \u2014 tell the user that, not that a tool call will fetch them (\`import_status\` refreshes status/progress only; \`pull_leads\` reads the active lens, so an imported lead outside it may not appear; re-running the import later re-reconciles those companies).
 
 **Deliver the augmented file back to the user**: the original file plus a new \`LEADBAY_ID\` column populated from the resolution step. This is the second deliverable of a job well done.
 
@@ -1731,6 +1731,34 @@ var LeadbayClient = class {
   defaultLensCachedAt = null;
   mePayload = null;
   mePayloadCachedAt = null;
+  // Monotonic sequence bumped whenever the telemetry preference is decided by a
+  // fresher signal — an explicit stamp (setCachedTelemetryEnabled) or the START
+  // of a telemetry read (resolveMe / fetchTelemetryEnabled). A read snapshots it
+  // and only writes telemetryEnabledCache if the sequence is UNCHANGED when it
+  // completes, so (a) a stamp landing mid-read wins over the stale read and (b)
+  // an older overlapping read that resolves last can't clobber a newer read's
+  // value (product#3879, Codex P1).
+  telemetryStateSeq = 0;
+  // The telemetry preference lives in its OWN field, separate from mePayload,
+  // so it survives invalidateMe() (Codex P1). Otherwise a leadbay_set_telemetry
+  // disable would be forgotten the moment the very next same-session tool
+  // invalidates the /me cache (refine_prompt, my_lenses, set_active_lens, …),
+  // dropping cachedTelemetryEnabled() back to undefined and letting the hosted
+  // suppression predicate fall through to a stale "enabled". undefined = never
+  // observed; the last read/stamp always wins and persists across /me churn.
+  telemetryEnabledCache = void 0;
+  // True when telemetryEnabledCache came from an EXPLICIT user stamp
+  // (leadbay_set_telemetry via setCachedTelemetryEnabled), as opposed to a
+  // /users/me read. A stamp is the user's direct choice for THIS request and is
+  // the single most authoritative signal — it outranks even a fail-closed
+  // verdict from a timed-out/errored read, so a same-request opt-IN takes effect
+  // even when a background refresh just failed closed (Codex P2). Reset to false
+  // whenever a read writes the cache or the tenant switches.
+  telemetryEnabledFromStamp = false;
+  // Counts explicit user stamps only. Unlike telemetryStateSeq, read-starts do
+  // not move it, so callers can distinguish "a same-message stamp happened" from
+  // "a background refresh merely started" when demoting stale opt-in stamps.
+  telemetryStampStateSeq = 0;
   tasteProfile = null;
   tasteProfileCachedAt = null;
   // Simple semaphore for concurrency limiting.
@@ -1766,20 +1794,28 @@ var LeadbayClient = class {
   get lastMeta() {
     return this._lastMeta;
   }
-  // Used by login when region auto-detect picks a different backend than the
-  // one the client was constructed with.
-  setBaseUrl(baseUrl, region) {
-    this._baseUrl = baseUrl.replace(/\/+$/, "");
-    this._region = region ?? (baseUrl === REGIONS.us ? "us" : baseUrl === REGIONS.fr ? "fr" : "custom");
+  clearTenantScopedCaches() {
     this.defaultLensId = null;
     this.defaultLensCachedAt = null;
     this.mePayload = null;
     this.mePayloadCachedAt = null;
     this.tasteProfile = null;
     this.tasteProfileCachedAt = null;
+    this.telemetryEnabledCache = void 0;
+    this.telemetryEnabledFromStamp = false;
+    this.telemetryStateSeq++;
+    this.telemetryStampStateSeq++;
+  }
+  // Used by login when region auto-detect picks a different backend than the
+  // one the client was constructed with.
+  setBaseUrl(baseUrl, region) {
+    this._baseUrl = baseUrl.replace(/\/+$/, "");
+    this._region = region ?? (baseUrl === REGIONS.us ? "us" : baseUrl === REGIONS.fr ? "fr" : "custom");
+    this.clearTenantScopedCaches();
   }
   setToken(token) {
     this.token = token;
+    this.clearTenantScopedCaches();
   }
   get isAuthenticated() {
     return this.token !== null;
@@ -2060,17 +2096,139 @@ var LeadbayClient = class {
     if (!force && this.mePayload !== null && this.mePayloadCachedAt !== null && now - this.mePayloadCachedAt < ME_CACHE_TTL_MS) {
       return this.mePayload;
     }
+    const seqAtStart = ++this.telemetryStateSeq;
     const me = await this.request("GET", "/users/me");
     this.mePayload = me;
     this.mePayloadCachedAt = now;
+    if (this.telemetryStateSeq === seqAtStart && me.telemetry_enabled !== void 0) {
+      this.telemetryEnabledCache = me.telemetry_enabled;
+      this.telemetryEnabledFromStamp = false;
+    }
     return me;
   }
+  // Lightweight cross-session telemetry-preference read for the hosted SSE
+  // per-message refresh (product#3879, Codex P2). UNLIKE resolveMe() this does
+  // NOT touch mePayload / the general /me cache — so a slow background refresh
+  // can never repopulate a stale last_requested_lens over a tool's mutation, and
+  // it never serves the 60s /me cache (always a fresh read). It reads the SAME
+  // /users/me endpoint (telemetry_enabled lives there) but only reconciles the
+  // dedicated telemetry field, under the same sequence guard as resolveMe.
+  //
+  // It deliberately bypasses request() and therefore never writes _lastMeta
+  // (Codex P2): the refresh shares the tool's client, and request() rewrites
+  // _lastMeta on every call. Without isolation, a refresh completing between a
+  // tool's real backend call and that tool copying client.lastMeta into its
+  // result (e.g. pull-leads' _meta.latency_ms) could make the metadata describe
+  // GET /users/me instead of the tool call.
+  //
+  // Returns the observed preference: true/false, or undefined when the backend
+  // omitted the field (older backend → caller treats as enabled default).
+  async fetchTelemetryEnabled() {
+    const seqAtStart = ++this.telemetryStateSeq;
+    if (process.env.LEADBAY_MOCK === "1") {
+      const metaBefore = this._lastMeta;
+      try {
+        const me = this.mockRequest("GET", "/users/me");
+        const observed = me.telemetry_enabled;
+        if (this.telemetryStateSeq === seqAtStart && observed !== void 0) {
+          this.telemetryEnabledCache = observed;
+          this.telemetryEnabledFromStamp = false;
+        }
+        return observed;
+      } finally {
+        this._lastMeta = metaBefore;
+      }
+    }
+    if (!this.token) {
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN in your MCP client config, or run: npx -y -p @leadbay/mcp@latest installer", "/users/me");
+    }
+    await this.acquireSemaphore();
+    try {
+      const res = await this.httpsRequestWithRetry("GET", `${this._baseUrl}${API_PREFIX}/users/me`, { Authorization: `Bearer ${this.token}` }, void 0);
+      if (res.status < 200 || res.status >= 300) {
+        throw this.mapErrorResponse(res.status, res.body, "/users/me", res.headers);
+      }
+      const me = JSON.parse(res.body);
+      const observed = me.telemetry_enabled;
+      if (this.telemetryStateSeq === seqAtStart && observed !== void 0) {
+        this.telemetryEnabledCache = observed;
+        this.telemetryEnabledFromStamp = false;
+      }
+      return observed;
+    } finally {
+      this.releaseSemaphore();
+    }
+  }
   // Force re-fetch on next resolveMe(). Call from any tool that mutates a
-  // /me-cached field (last_requested_lens, billing, etc.).
+  // /me-cached field (last_requested_lens, billing, etc.). Deliberately does
+  // NOT clear telemetryEnabledCache — the opt-out preference is orthogonal to
+  // /me staleness and must survive invalidation (Codex P1).
   invalidateMe() {
     this.mePayload = null;
     this.mePayloadCachedAt = null;
   }
+  // Synchronous read of the last-cached telemetry preference, without a fetch.
+  // Returns undefined when /users/me hasn't been resolved (or was invalidated).
+  // The hosted telemetry suppression predicate reads this AT CAPTURE TIME so a
+  // leadbay_set_telemetry disable within the same request suppresses that very
+  // request's tracking — the opt-out action isn't itself the last tracked event
+  // (product#3879). resolveMe() keeps mePayload populated after a write, so this
+  // reflects the post-write state.
+  cachedTelemetryEnabled() {
+    return this.telemetryEnabledCache;
+  }
+  // True when the cached preference came from an explicit user stamp (a
+  // leadbay_set_telemetry toggle), not a read. The hosted suppression predicate
+  // treats a stamp as the single most-authoritative signal — it outranks a
+  // fail-closed verdict from a failed background read, so a same-request opt-IN
+  // takes effect even when a refresh just timed out (product#3879, Codex P2).
+  cachedTelemetryStamped() {
+    return this.telemetryEnabledFromStamp && this.telemetryEnabledCache !== void 0;
+  }
+  // Monotonic sequence exposed so callers can tell whether a telemetry stamp
+  // happened AFTER a reference point (e.g. an SSE message start). Bumped by every
+  // stamp and every telemetry read-start; see telemetryStateSeq.
+  telemetrySeq() {
+    return this.telemetryStateSeq;
+  }
+  // Monotonic sequence moved only by explicit user stamps. Used by the SSE
+  // refresh failure path to demote stale opt-in stamps without mistaking a
+  // read-start sequence bump for a same-message opt-in.
+  telemetryStampSeq() {
+    return this.telemetryStampStateSeq;
+  }
+  // Demote the cached preference from "explicit stamp" to ordinary read-level
+  // authority WITHOUT changing its value. A stamp is scoped to the request that
+  // made it (Codex P2): once a LATER SSE message's refresh produces a
+  // fail-closed verdict (timeout/error), that earlier stamp must no longer
+  // outrank it, or a session that once enabled would keep emitting through every
+  // subsequent unreadable refresh.
+  //
+  // `onlyIfStampSeqAtMost` guards against demoting a stamp made by the CURRENT
+  // message (Codex P2): pass the STAMP sequence captured at message start; if a
+  // stamp has bumped it beyond the snapshot, that stamp is same-message (a fresh
+  // opt-in) and must be preserved. Read-starts do not affect this guard.
+  clearTelemetryStampOrigin(onlyIfStampSeqAtMost) {
+    if (onlyIfStampSeqAtMost !== void 0 && this.telemetryStampStateSeq > onlyIfStampSeqAtMost) {
+      return;
+    }
+    this.telemetryEnabledFromStamp = false;
+  }
+  // Deterministically stamp the cached telemetry preference to a known value,
+  // WITHOUT a fetch. leadbay_set_telemetry calls this right after a successful
+  // POST /users/telemetry so the suppression predicate reflects the new state
+  // even if the follow-up refresh fails (product#3879) — a disable must never
+  // fail open and let the opt-out request emit error telemetry. Creates a
+  // minimal cache entry if /users/me was never resolved.
+  setCachedTelemetryEnabled(enabled) {
+    this.telemetryStateSeq++;
+    this.telemetryStampStateSeq++;
+    this.telemetryEnabledCache = enabled;
+    this.telemetryEnabledFromStamp = true;
+    if (this.mePayload) {
+      this.mePayload = { ...this.mePayload, telemetry_enabled: enabled };
+    }
+  }
   async resolveDefaultLens() {
     const now = Date.now();
     if (this.defaultLensId !== null && this.defaultLensCachedAt !== null && now - this.defaultLensCachedAt < LENS_CACHE_TTL_MS) {
@@ -8181,6 +8339,8 @@ WHEN NOT TO USE: discovery (use leadbay_pull_leads); single-lead deep dive (use
 
 Budgets: \`total_budget_ms\` caps wall-clock; \`per_lead_budget_ms\` caps each lead's poll. For short transport timeouts, pass \`wait_for_completion:false\` and poll \`leadbay_import_status\`. Outputs \`qualified[]\`, \`still_running[]\`, \`not_imported[]\`, \`qualify_id\` (resumable handle). Idempotent within a 5-min window. \`dry_run:'preview'\` returns mapping hints + custom-field candidates without importing.
 
+\`not_imported\` rows with \`reason:"uncrawled"\` are **pending a background crawl**, NOT failures: Leadbay just hasn't matched/crawled that domain yet and will add the lead asynchronously (the label doesn't verify the URL resolves \u2014 don't call the site bad, but don't certify it valid either). Surface them as pending; the leads populate in the user's Leadbay account as the crawl completes (no tool here fetches them on demand \u2014 \`leadbay_import_status\` returns status/progress only, and \`leadbay_pull_leads\` reads the active lens's wishlist so an imported lead outside that lens may not appear). To pull those specific companies back through the MCP, re-run the import later. A large \`uncrawled\` share on a fresh list is normal.
+
 This tool MUTATES state. The caller (agent or human-in-the-loop) is responsible for confirming intent before invocation; the MCP server does not soft-prompt for confirmation. See \`annotations.destructiveHint\`.
 
 
@@ -8192,18 +8352,42 @@ Requires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role;
 
 The response carries either a completed result or an async handle. Render a brief summary; do NOT enumerate every imported lead.
 
+**Dry run first:** if the result has \`dry_run:true\` (or ANY \`not_imported\` row has \`reason: "dry_run"\`), this was a VALIDATION pass \u2014 nothing was committed. Render \`"\u{1F50E} Dry run \u2014 V rows validated OK, nothing imported yet. Re-run without dry_run to commit."\` where V = the count of \`dry_run\` rows. If malformed rows are ALSO present (\`reason: "malformed"\`), list those separately as \`"\u26A0 M rows can't be imported as-is: <row \xB7 malformed>"\` so the validation count is never swallowed. Do NOT use the pending-crawl/need-attention bucket header below for a dry run (those buckets are for a real committed import).
+
+Otherwise, partition \`not_imported\` by \`reason\` into these buckets before you write the header:
+
+- **Pending crawl** \u2014 \`reason: "uncrawled"\` **AND the row has a \`domain\`**: Leadbay just hasn't crawled that domain yet and will add the lead asynchronously. These are NOT failures. (The label doesn't verify the URL resolves \u2014 don't claim the site is bad, but don't certify it's valid either. See the note below.)
+- **Need attention** \u2014 everything else that didn't import:
+  - \`reason: "uncrawled"\` but the row has **no \`domain\`** (name/CRM-id-only row): there is nothing for Leadbay to crawl, so it will NOT self-resolve \u2014 count these under need-attention, not pending crawl, and tell the user to supply a company website/identity and re-import.
+  - \`reason\` \u2208 \`malformed\` / \`internal_error\` / \`no_match\` / \`ambiguous\`: genuinely un-actionable or needs a follow-up call.
+
 **Header \u2014 single line, choose by status:**
 
-- Completed: \`"\u2713 Import complete \u2014 N leads imported \xB7 M failed \xB7 P resolved-with-ambiguity"\`
+- Completed: \`"\u2713 Import complete \u2014 N imported \xB7 P pending crawl \xB7 Q need attention"\` (drop any segment whose count is 0)
 - 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*"\`.
+Count \`uncrawled\` rows as **pending**, never as failures \u2014 never say "M failed" when the M is mostly/entirely uncrawled rows.
+
+**When the "need attention" or pending-crawl rows are non-empty**, follow the header with a small bulleted list (\u2264 5 items): \`<row identifier or domain> \xB7 <reason>\`. Label each row by its real reason \u2014 "pending crawl" for \`uncrawled\`, and the specific reason otherwise. Frame pending rows reassuringly (Leadbay is crawling them; the leads it adds will populate in the user's Leadbay account as the crawl completes \u2014 see the semantics note below for where they show up), not as errors. The full \`not_imported\` breakdown is already in THIS response \u2014 list from it directly; then \`"*+N more (see the full not_imported list in the response)*"\`.
 
 **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.
 
+**\`uncrawled\` is NOT a failed import \u2014 it means "pending a crawl".** A row lands \`uncrawled\` when Leadbay hasn't matched or crawled that domain **yet** \u2014 the row simply didn't match an existing lead at import time and isn't a public-mailbox domain. It does NOT mean the import failed, and it is NOT a verdict that the website is broken (the tool doesn't check whether the URL resolves \u2014 so don't claim the site is bad, but don't guarantee it's valid either).
+
+**One caveat \u2014 \`uncrawled\` only means "pending" when the row actually had a website.** A row imported by name / CRM id / registry number only (no \`LEAD_WEBSITE\` mapped) that finds no existing match ALSO lands \`uncrawled\`, but there's no domain for Leadbay to crawl \u2014 so it will NOT self-resolve via a late crawl. For those name-only rows, don't give the "Leadbay is crawling it" reassurance; tell the user to supply a company website (or another resolvable identity) and re-import. So: \`uncrawled\` + a website \u2192 genuinely pending a background crawl; \`uncrawled\` + no website \u2192 the user needs to add an identity, it won't crawl on its own. The import itself completed successfully; Leadbay then crawls the domain in the background and adds the lead asynchronously (a *late import*), so most of these rows resolve on their own within minutes to hours. Where do those late-added leads show up? **In the user's Leadbay account as the crawl completes.** \`leadbay_import_status\` does NOT return them \u2014 it only refreshes status/progress. There's no bulk "list the leads this import just added" call: \`leadbay_pull_leads\` reads the active lens's wishlist, so an imported lead not admitted to that lens won't appear there. For **one specific company by name**, \`leadbay_research_lead_by_name_fuzzy\` searches across the visible Leadbay corpus (not lens-scoped) and can surface it once crawled \u2014 a reasonable check for a named company. Otherwise tell the user the leads will populate in Leadbay over the next minutes\u2013hours; to pull those specific companies back through the MCP in bulk, **re-run the same import later** (the now-crawled domains match). Do NOT promise \`leadbay_pull_leads\` or \`import_status\` will list the late additions.
+
+So when reporting an import: count \`uncrawled\` rows as **pending**, never as failures. Do NOT tell the user these rows "failed", were "rejected", had "bad/unreachable websites", or point to a backend problem \u2014 that is wrong and needlessly erodes trust in the whole lead set. A high \`uncrawled\` share on a fresh list is normal and expected, not a red flag.
+
+How the OTHER reasons map to the "Need attention" bucket (see the render block above) \u2014 none of these should be lumped in with \`uncrawled\`/pending, but each is still surfaced to the user, not suppressed:
+
+- \`malformed\` (row couldn't be parsed) and \`internal_error\` (a real backend error) are genuine failures \u2014 flag them plainly.
+- \`no_match\` on a public-mailbox domain (gmail.com, outlook.com, \u2026) means no company domain was resolvable from that row \u2014 surface it so the user can supply a real company domain. Not a crawler failure.
+- \`ambiguous\` rows matched several candidates \u2014 surface them as needing disambiguation via \`leadbay_resolve_import_rows\`. Not a failure, but the user still needs to act.
+
+
 
 ---
 
@@ -8231,8 +8415,9 @@ User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutual
 |------------------------------------------------|---------------------------------------------------------------|--------------------------------------------------------|
 | Status: running                                | "Check progress"                                              | leadbay_import_status(handle_id)                       |
 | Status: complete, imports succeeded            | "Run AI qualification on the imported leads"                  | leadbay_bulk_qualify_leads([leadIds]) \u2014 or use leadbay_import_and_qualify next time |
+| Pending-crawl (\`uncrawled\`) rows present       | "Re-run the import for those domains later, once Leadbay has crawled them" | leadbay_import_leads (re-run with just the uncrawled domains, later \u2014 they re-reconcile once crawled). NOTE: not a live-fetch of the added leads; those populate in the user's Leadbay account as the crawl completes |
 | Ambiguous / unresolved rows present            | "Resolve the ambiguous rows"                                  | leadbay_resolve_import_rows(records, identity_mappings)|
-| Failed rows from bad mappings                  | "Check the org's mappable fields and remap"                   | leadbay_list_mappable_fields                           |
+| \`malformed\` / bad-mapping rows present         | "Check the org's mappable fields and remap the bad rows"      | leadbay_list_mappable_fields                           |
 | User wants to see the imported leads           | "See the imported leads in your view"                         | leadbay_pull_leads                                     |
 | User had follow-up intent for the imports      | "Prep outreach for [a specific imported lead]"                | leadbay_prepare_outreach(leadId)                       |
 `;
@@ -8240,6 +8425,8 @@ var leadbay_import_leads = `Import leads into Leadbay's CRM via the file-import
 
 TWO MODES: (A) Domain-list shortcut \u2014 pass \`domains: [{domain, name?}]\`. The tool builds a 2-column CSV (LEAD_NAME, LEAD_WEBSITE) and imports with the default mapping. (B) Custom records + mapping \u2014 pass \`records: [{Col1, Col2, ...}]\` plus \`mappings.fields: {Col1: 'LEAD_NAME', ...}\`. \`mappings.fields\` must include LEADBAY_ID, CRM_ID, SIREN, LEAD_NAME, or LEAD_WEBSITE (resolver needs at least one identity key). Pass exactly one of \`domains\` / \`records\`. Reserved column \`MCP_ROW_ID\` cannot appear in records/mappings \u2014 the tool injects it for stable reconciliation.
 
+\`not_imported\` rows with \`reason:"uncrawled"\` are **pending a background crawl**, NOT failures: Leadbay just hasn't matched/crawled that domain yet and will add the lead asynchronously (the label doesn't verify the URL resolves \u2014 don't call the site bad, but don't certify it valid either). Surface them as pending; the leads populate in the user's Leadbay account as the crawl completes (no tool here fetches them on demand \u2014 \`leadbay_import_status\` returns status/progress only, and \`leadbay_pull_leads\` reads the active lens's wishlist so an imported lead outside that lens may not appear). To pull those specific companies back through the MCP, re-run the import later. A large \`uncrawled\` share on a fresh list is normal.
+
 MUTATES USER STATE: each call creates a row in the user's CRM-imports list (visible in the web UI) and touches onboarding state. Suitable for occasional automation, NOT for high-cadence (>5 calls/day). Imported leads are NOT auto-promoted to the user's Monitor view; lens-scoring threshold decides. For messy files call leadbay_resolve_import_rows first, then pass \`records_for_import\`/\`mappings_for_import\` here. Agents should inspect every column, build a preservation plan, and pass an explicit final mapping. For each meaningful column decide standard field, CONTACT_* field, Leadbay note, custom field, derived helper, or skip with a reason. For contact-only exports, derive a company-domain column from CONTACT_EMAIL only when it's a real business domain. Multiple rows can share the same LEADBAY_ID and import as separate contacts on that lead. Custom fields use \`CUSTOM.<id>\` in \`mappings.fields\` or the \`mappings.custom_fields\` shorthand. For source-system deep links create a custom field via leadbay_create_custom_field first (prefer EXTERNAL_ID + url_template). Preserve meaningful per-lead notes by calling leadbay_add_note after import returns lead IDs.
 
 WHEN TO USE: you have a list of company domains from another system (CRM, analytics, email correspondents) and need stable Leadbay leadIds; or CRM-shaped rows with custom columns and want to drive the wizard with explicit field mappings.
@@ -8257,18 +8444,42 @@ Requires: LEADBAY_MCP_WRITE=1 (MCP) or exposeWrite=true (OpenClaw); admin role o
 
 The response carries either a completed result or an async handle. Render a brief summary; do NOT enumerate every imported lead.
 
+**Dry run first:** if the result has \`dry_run:true\` (or ANY \`not_imported\` row has \`reason: "dry_run"\`), this was a VALIDATION pass \u2014 nothing was committed. Render \`"\u{1F50E} Dry run \u2014 V rows validated OK, nothing imported yet. Re-run without dry_run to commit."\` where V = the count of \`dry_run\` rows. If malformed rows are ALSO present (\`reason: "malformed"\`), list those separately as \`"\u26A0 M rows can't be imported as-is: <row \xB7 malformed>"\` so the validation count is never swallowed. Do NOT use the pending-crawl/need-attention bucket header below for a dry run (those buckets are for a real committed import).
+
+Otherwise, partition \`not_imported\` by \`reason\` into these buckets before you write the header:
+
+- **Pending crawl** \u2014 \`reason: "uncrawled"\` **AND the row has a \`domain\`**: Leadbay just hasn't crawled that domain yet and will add the lead asynchronously. These are NOT failures. (The label doesn't verify the URL resolves \u2014 don't claim the site is bad, but don't certify it's valid either. See the note below.)
+- **Need attention** \u2014 everything else that didn't import:
+  - \`reason: "uncrawled"\` but the row has **no \`domain\`** (name/CRM-id-only row): there is nothing for Leadbay to crawl, so it will NOT self-resolve \u2014 count these under need-attention, not pending crawl, and tell the user to supply a company website/identity and re-import.
+  - \`reason\` \u2208 \`malformed\` / \`internal_error\` / \`no_match\` / \`ambiguous\`: genuinely un-actionable or needs a follow-up call.
+
 **Header \u2014 single line, choose by status:**
 
-- Completed: \`"\u2713 Import complete \u2014 N leads imported \xB7 M failed \xB7 P resolved-with-ambiguity"\`
+- Completed: \`"\u2713 Import complete \u2014 N imported \xB7 P pending crawl \xB7 Q need attention"\` (drop any segment whose count is 0)
 - 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*"\`.
+Count \`uncrawled\` rows as **pending**, never as failures \u2014 never say "M failed" when the M is mostly/entirely uncrawled rows.
+
+**When the "need attention" or pending-crawl rows are non-empty**, follow the header with a small bulleted list (\u2264 5 items): \`<row identifier or domain> \xB7 <reason>\`. Label each row by its real reason \u2014 "pending crawl" for \`uncrawled\`, and the specific reason otherwise. Frame pending rows reassuringly (Leadbay is crawling them; the leads it adds will populate in the user's Leadbay account as the crawl completes \u2014 see the semantics note below for where they show up), not as errors. The full \`not_imported\` breakdown is already in THIS response \u2014 list from it directly; then \`"*+N more (see the full not_imported list in the response)*"\`.
 
 **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.
 
+**\`uncrawled\` is NOT a failed import \u2014 it means "pending a crawl".** A row lands \`uncrawled\` when Leadbay hasn't matched or crawled that domain **yet** \u2014 the row simply didn't match an existing lead at import time and isn't a public-mailbox domain. It does NOT mean the import failed, and it is NOT a verdict that the website is broken (the tool doesn't check whether the URL resolves \u2014 so don't claim the site is bad, but don't guarantee it's valid either).
+
+**One caveat \u2014 \`uncrawled\` only means "pending" when the row actually had a website.** A row imported by name / CRM id / registry number only (no \`LEAD_WEBSITE\` mapped) that finds no existing match ALSO lands \`uncrawled\`, but there's no domain for Leadbay to crawl \u2014 so it will NOT self-resolve via a late crawl. For those name-only rows, don't give the "Leadbay is crawling it" reassurance; tell the user to supply a company website (or another resolvable identity) and re-import. So: \`uncrawled\` + a website \u2192 genuinely pending a background crawl; \`uncrawled\` + no website \u2192 the user needs to add an identity, it won't crawl on its own. The import itself completed successfully; Leadbay then crawls the domain in the background and adds the lead asynchronously (a *late import*), so most of these rows resolve on their own within minutes to hours. Where do those late-added leads show up? **In the user's Leadbay account as the crawl completes.** \`leadbay_import_status\` does NOT return them \u2014 it only refreshes status/progress. There's no bulk "list the leads this import just added" call: \`leadbay_pull_leads\` reads the active lens's wishlist, so an imported lead not admitted to that lens won't appear there. For **one specific company by name**, \`leadbay_research_lead_by_name_fuzzy\` searches across the visible Leadbay corpus (not lens-scoped) and can surface it once crawled \u2014 a reasonable check for a named company. Otherwise tell the user the leads will populate in Leadbay over the next minutes\u2013hours; to pull those specific companies back through the MCP in bulk, **re-run the same import later** (the now-crawled domains match). Do NOT promise \`leadbay_pull_leads\` or \`import_status\` will list the late additions.
+
+So when reporting an import: count \`uncrawled\` rows as **pending**, never as failures. Do NOT tell the user these rows "failed", were "rejected", had "bad/unreachable websites", or point to a backend problem \u2014 that is wrong and needlessly erodes trust in the whole lead set. A high \`uncrawled\` share on a fresh list is normal and expected, not a red flag.
+
+How the OTHER reasons map to the "Need attention" bucket (see the render block above) \u2014 none of these should be lumped in with \`uncrawled\`/pending, but each is still surfaced to the user, not suppressed:
+
+- \`malformed\` (row couldn't be parsed) and \`internal_error\` (a real backend error) are genuine failures \u2014 flag them plainly.
+- \`no_match\` on a public-mailbox domain (gmail.com, outlook.com, \u2026) means no company domain was resolvable from that row \u2014 surface it so the user can supply a real company domain. Not a crawler failure.
+- \`ambiguous\` rows matched several candidates \u2014 surface them as needing disambiguation via \`leadbay_resolve_import_rows\`. Not a failure, but the user still needs to act.
+
+
 
 ---
 
@@ -8296,14 +8507,15 @@ User picks \u2192 call the matching \`Calls\` tool. Constraints: 2\u20134 mutual
 |------------------------------------------------|---------------------------------------------------------------|--------------------------------------------------------|
 | Status: running                                | "Check progress"                                              | leadbay_import_status(handle_id)                       |
 | Status: complete, imports succeeded            | "Run AI qualification on the imported leads"                  | leadbay_bulk_qualify_leads([leadIds]) \u2014 or use leadbay_import_and_qualify next time |
+| Pending-crawl (\`uncrawled\`) rows present       | "Re-run the import for those domains later, once Leadbay has crawled them" | leadbay_import_leads (re-run with just the uncrawled domains, later \u2014 they re-reconcile once crawled). NOTE: not a live-fetch of the added leads; those populate in the user's Leadbay account as the crawl completes |
 | Ambiguous / unresolved rows present            | "Resolve the ambiguous rows"                                  | leadbay_resolve_import_rows(records, identity_mappings)|
-| Failed rows from bad mappings                  | "Check the org's mappable fields and remap"                   | leadbay_list_mappable_fields                           |
+| \`malformed\` / bad-mapping rows present         | "Check the org's mappable fields and remap the bad rows"      | leadbay_list_mappable_fields                           |
 | User wants to see the imported leads           | "See the imported leads in your view"                         | leadbay_pull_leads                                     |
 | User had follow-up intent for the imports      | "Prep outreach for [a specific imported lead]"                | leadbay_prepare_outreach(leadId)                       |
 `;
-var leadbay_import_status = `Retrieve the current state of an async lead import. Pass \`handle_id\` returned by \`leadbay_import_leads({wait_for_completion:false})\`, or pass legacy \`importIds[]\` to inspect backend wizard rows. This status call performs a single refresh pass and never polls in a loop.
+var leadbay_import_status = `Retrieve the current **status/progress** of a lead import. Pass \`handle_id\` \u2014 returned by either \`leadbay_import_leads\` OR \`leadbay_import_and_qualify\` when called with \`wait_for_completion:false\` \u2014 to resolve the stored result (leads + not_imported) once that async run has completed in this MCP instance. **If you were given a \`handle_id\`, poll with it, not with \`importIds[]\`** \u2014 only the \`handle_id\` path returns the stored result/not_imported breakdown. Pass \`importIds[]\` (a completed import returns \`importIds\`; \`leadbay_import_and_qualify\` returns \`import_ids\`) only when you don't have a handle, to refresh the backend wizard rows' phase + record counts. Note: the \`importIds[]\` path returns status/progress only \u2014 it does NOT re-reconcile records or return refreshed leads/not_imported. This status call performs a single refresh pass and never polls in a loop.
 
-WHEN TO USE: after leadbay_import_leads or leadbay_import_and_qualify returns \`{status:'running', handle_id}\` for the import phase, call this tool later to retrieve progress or the final import result without re-running the import.
+WHEN TO USE: after an async import (\`leadbay_import_leads\` OR \`leadbay_import_and_qualify\` with \`wait_for_completion:false\`) returns \`{status:'running', handle_id}\`, poll with that \`handle_id\`; OR to check whether a finished import is still processing. This tool does NOT surface the leads Leadbay adds later for pending-crawl (\`uncrawled\`) rows \u2014 those populate in the user's Leadbay account as the crawl completes; no tool here fetches them on demand (re-run the import to pull them back through the MCP).
 
 WHEN NOT TO USE: for qualification handles returned as \`qualify_id\` \u2014 use leadbay_qualify_status for those; or when you still want the legacy blocking behavior from leadbay_import_leads with \`wait_for_completion=true\`.
 
@@ -8325,19 +8537,39 @@ After the status line, propose the obvious refresh / progress-check / recovery a
 
 Specifically for import status:
 
-- Running \u2192 \`"\u23F3 Import still running \u2014 N% complete; check back in ~M minutes."\`
-- Complete \u2192 \`"\u2713 Import complete \u2014 N leads imported, M failed."\`
-- Error / failed \u2192 \`"\u26A0 Import failed: <error>. See leadbay_resolve_import_rows for diagnosis."\`
+This tool returns \`status\`, \`importIds\`, and \`progress\` ({phase, records_processed, records_total}). It carries a \`result\` object (with \`leads\` + \`not_imported\`) ONLY when resolving an async \`handle_id\` whose run completed in this MCP instance \u2014 the \`importIds[]\` status-check path does NOT return \`result\`. **Render only from the fields actually present; never invent counts.**
+
+Caveat on \`progress\`: \`records_processed\` counts only the rows that MATCHED an existing lead (backend \`imported_records\`), not every row that finished processing \u2014 so for a complete import whose rows are mostly/all \`uncrawled\` (pending crawl), \`records_processed\` is legitimately low or 0. Never read a low \`records_processed\` on a \`complete\` import as "stuck" or "failed": once \`status:"complete"\`, processing is done; the pending-crawl rows just matched no existing lead yet.
+
+- Running \u2192 \`"\u23F3 Import still running \u2014 phase <phase>; check back in ~M minutes."\` (use the phase; don't turn the matched-count into an "X/Y processed" progress bar).
+- Complete, **no \`result\`** (the usual \`importIds\` status check) \u2192 \`"\u2713 Import complete."\` Do NOT append a \`records_processed/records_total\` fraction (it undercounts pending-crawl rows and looks stuck) and do NOT report pending-crawl / need-attention bucket counts \u2014 the row-level \`not_imported\` breakdown isn't in this response.
+- Complete, **\`result\` present AND it was a dry run** (\`result.dry_run:true\`, or every \`result.not_imported\` row has \`reason:"dry_run"\`) \u2192 this resolved handle was a VALIDATION pass, nothing committed. Render \`"\u{1F50E} Dry run complete \u2014 V rows validated, nothing imported. Re-run without dry_run to commit."\` \u2014 do NOT render it as a real import completion or use the pending/attention buckets.
+- Complete, **\`result\` present** (async handle resolved, real import) \u2192 then, and only then, partition \`result.not_imported\` as in the shared import-result render block below \u2014 \`"\u2713 Import complete \u2014 N imported \xB7 P pending crawl \xB7 Q need attention"\` where **pending crawl** is \`uncrawled\` rows that HAVE a \`domain\` (not failures) and no-\`domain\` \`uncrawled\` rows fall under need-attention. Drop any zero segment.
+- Error / failed \u2192 \`"\u26A0 Import failed: <error>. See leadbay_resolve_import_rows for diagnosis."\` \u2014 reserve this ONLY for a true transport/backend error on the import itself, never for \`uncrawled\` rows.
+
+**\`uncrawled\` is NOT a failed import \u2014 it means "pending a crawl".** A row lands \`uncrawled\` when Leadbay hasn't matched or crawled that domain **yet** \u2014 the row simply didn't match an existing lead at import time and isn't a public-mailbox domain. It does NOT mean the import failed, and it is NOT a verdict that the website is broken (the tool doesn't check whether the URL resolves \u2014 so don't claim the site is bad, but don't guarantee it's valid either).
+
+**One caveat \u2014 \`uncrawled\` only means "pending" when the row actually had a website.** A row imported by name / CRM id / registry number only (no \`LEAD_WEBSITE\` mapped) that finds no existing match ALSO lands \`uncrawled\`, but there's no domain for Leadbay to crawl \u2014 so it will NOT self-resolve via a late crawl. For those name-only rows, don't give the "Leadbay is crawling it" reassurance; tell the user to supply a company website (or another resolvable identity) and re-import. So: \`uncrawled\` + a website \u2192 genuinely pending a background crawl; \`uncrawled\` + no website \u2192 the user needs to add an identity, it won't crawl on its own. The import itself completed successfully; Leadbay then crawls the domain in the background and adds the lead asynchronously (a *late import*), so most of these rows resolve on their own within minutes to hours. Where do those late-added leads show up? **In the user's Leadbay account as the crawl completes.** \`leadbay_import_status\` does NOT return them \u2014 it only refreshes status/progress. There's no bulk "list the leads this import just added" call: \`leadbay_pull_leads\` reads the active lens's wishlist, so an imported lead not admitted to that lens won't appear there. For **one specific company by name**, \`leadbay_research_lead_by_name_fuzzy\` searches across the visible Leadbay corpus (not lens-scoped) and can surface it once crawled \u2014 a reasonable check for a named company. Otherwise tell the user the leads will populate in Leadbay over the next minutes\u2013hours; to pull those specific companies back through the MCP in bulk, **re-run the same import later** (the now-crawled domains match). Do NOT promise \`leadbay_pull_leads\` or \`import_status\` will list the late additions.
+
+So when reporting an import: count \`uncrawled\` rows as **pending**, never as failures. Do NOT tell the user these rows "failed", were "rejected", had "bad/unreachable websites", or point to a backend problem \u2014 that is wrong and needlessly erodes trust in the whole lead set. A high \`uncrawled\` share on a fresh list is normal and expected, not a red flag.
+
+How the OTHER reasons map to the "Need attention" bucket (see the render block above) \u2014 none of these should be lumped in with \`uncrawled\`/pending, but each is still surfaced to the user, not suppressed:
+
+- \`malformed\` (row couldn't be parsed) and \`internal_error\` (a real backend error) are genuine failures \u2014 flag them plainly.
+- \`no_match\` on a public-mailbox domain (gmail.com, outlook.com, \u2026) means no company domain was resolvable from that row \u2014 surface it so the user can supply a real company domain. Not a crawler failure.
+- \`ambiguous\` rows matched several candidates \u2014 surface them as needing disambiguation via \`leadbay_resolve_import_rows\`. Not a failure, but the user still needs to act.
+
 
 ---
 
 ## NEXT STEPS
 
-| Observation             | Suggest                                | Calls                          |
-|-------------------------|----------------------------------------|--------------------------------|
-| Status: complete        | "See the imported leads"               | leadbay_pull_leads             |
-| Status: running         | "Check again in N minutes"             | leadbay_import_status \u2014 re-call|
-| Status: error / failed  | "Diagnose the failure"                 | leadbay_resolve_import_rows    |
+| Observation                          | Suggest                                              | Calls                          |
+|--------------------------------------|------------------------------------------------------|--------------------------------|
+| Status: complete                     | "See the imported (matched) leads"                   | leadbay_pull_leads             |
+| Pending-crawl (\`uncrawled\`) rows     | "Re-run the import for those domains later, once Leadbay has crawled them" | leadbay_import_leads (re-run with just the uncrawled domains, later \u2014 they re-reconcile once crawled). The added leads otherwise populate in the user's Leadbay account as the crawl completes; no live-fetch here |
+| Status: running                      | "Check again in N minutes"                           | leadbay_import_status \u2014 re-call|
+| Status: error / failed (true error)  | "Diagnose the failure"                               | leadbay_resolve_import_rows    |
 `;
 var leadbay_launch_bulk_enrichment = `Launch a bulk-enrichment job against the current selection. The backend requires \`email=true\` OR \`phone=true\` (both can be true). Returns 204 with no body \u2014 there is no bulk_id and no per-job status endpoint. Track results by polling individual leads via leadbay_get_contacts after ~60s; a contact is done for this run only when the REQUESTED channel landed (requested \`email\` and/or \`phone_number\` present), not \`contact.enrichment.done\` alone (that flag is already true for a contact enriched on the other channel earlier). \`dry_run:true\` returns the call shape without contacting the backend.
 
@@ -9938,7 +10170,7 @@ When \`_meta.match_candidates\` is non-empty, prepend one extra NEXT STEPS row:
 `;
 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\`.
 
-WHEN TO USE: before importing user-supplied files when domains, names, CRM IDs, registry numbers, or Leadbay IDs may be inconsistently formatted; when the agent needs to pre-resolve messy rows, inspect ambiguous candidates, or prepare LEADBAY_ID values for the import composites. For contact-only files, first derive company website/domain from business contact emails where possible, while ignoring consumer mailbox domains. Deterministic matches get a LEADBAY_ID column inserted so the standard import commits immediately. Ambiguous rows are deliberately left without LEADBAY_ID; inspect candidates and choose one only when the evidence is good. Rows with websites but no match can still be imported; Leadbay may crawl and match them later, and leadbay_import_status can surface late matches.
+WHEN TO USE: before importing user-supplied files when domains, names, CRM IDs, registry numbers, or Leadbay IDs may be inconsistently formatted; when the agent needs to pre-resolve messy rows, inspect ambiguous candidates, or prepare LEADBAY_ID values for the import composites. For contact-only files, first derive company website/domain from business contact emails where possible, while ignoring consumer mailbox domains. Deterministic matches get a LEADBAY_ID column inserted so the standard import commits immediately. Ambiguous rows are deliberately left without LEADBAY_ID; inspect candidates and choose one only when the evidence is good. Rows with websites but no match can still be imported; Leadbay may crawl and match them later (a late import), and those leads then populate in the user's Leadbay account as the crawl completes (no tool here fetches them on demand \u2014 re-run the import later to pull them back through the MCP).
 
 WHEN NOT TO USE: for prospect discovery from scratch (use leadbay_pull_leads); for one known company profile (use leadbay_research_lead_by_name_fuzzy / leadbay_research_lead_by_id); or when the file already has clean, final LEADBAY_ID/CRM_ID/SIREN mappings and no row-level identity disambiguation is needed.
 
@@ -9971,7 +10203,7 @@ Below the table, a one-liner: \`"Ready: K rows \xB7 Ambiguous: A rows \xB7 Unmat
 |----------------------------------------|-------------------------------------------------------------|--------------------------------------------------------|
 | All rows resolved cleanly              | "Import these rows now"                                     | leadbay_import_leads(records_for_import, mappings_for_import) |
 | Ambiguous rows present                 | "Inspect candidates for each ambiguous row"                 | (re-call with include_candidate_profiles=true)         |
-| Unmatched rows but websites present    | "Import anyway \u2014 Leadbay will crawl and match later"        | leadbay_import_leads (status check after)              |
+| Unmatched rows but websites present    | "Import anyway \u2014 Leadbay crawls & adds them to your account later" | leadbay_import_leads (the late-added leads populate in Leadbay; re-run the import to pull them back through the MCP) |
 | User wants to skip rows they can't ID  | "Drop unmatched rows and import the rest"                   | leadbay_import_leads (with filtered records)           |
 `;
 var leadbay_scan_portfolio_signals = `## WHEN TO USE
@@ -10336,6 +10568,67 @@ WHEN NOT TO USE: to READ the questions (use leadbay_get_qualification_questions)
 
 After a change, confirm in one line \u2014 e.g. **"Added 1 question \u2014 you now score leads against 4 questions."** or **"Removed 'the flooring question' \u2014 3 questions remain."** Then list the resulting questions as a numbered list. When the result is a non-changing preview (a removal awaiting confirmation), surface the \`hint\` (what would be removed) and ask the user to confirm \u2014 do NOT auto-confirm.
 `;
+var leadbay_set_telemetry = `## WHEN TO USE
+
+Trigger phrases: "disable telemetry", "turn off telemetry", "opt out of analytics", "stop sending usage data", "enable telemetry", "turn analytics back on", "is telemetry on", "is my usage being tracked", "what's my telemetry setting".
+
+**Memory:** recall + capture via \`leadbay_agent_memory_*\` tools.
+
+Prefer when: user wants to change or read the telemetry/analytics on-off preference for their account
+
+Examples that SHOULD invoke this tool:
+- "Turn off telemetry, I don't want my usage tracked."
+- "Re-enable analytics for my account."
+- "Is telemetry currently on for me?"
+
+Examples that should NOT invoke this tool (sound similar, route elsewhere):
+- "I want to report a bug in the pull-leads tool."
+- "Send feedback to the Leadbay team."
+- "Why isn't my event showing up in PostHog?"
+
+## RENDER (quick)
+
+One short confirmation line reflecting the result: state whether telemetry is
+now ON or OFF (or, for \`status\`, what it currently is) and \u2014 from \`hint\` \u2014
+the one-line way to flip it. No table; a single sentence is enough.
+
+---
+
+Enable, disable, or check **product-usage telemetry** for the current user.
+
+Telemetry (PostHog analytics \u2014 which tools fire, durations, error rates) is
+**ON by default** (opt-out model). It does not capture tool argument bodies,
+response bodies, or lead PII. This is a granular endpoint tool, so
+\`_triggered_by\` is optional like other granular tools; when it is present on an
+opt-out attempt, the MCP server suppresses/sanitizes the privacy-control
+telemetry paths so the opt-out prompt is not recorded. This tool is the
+in-product control so a user can change or check the setting without editing
+config. The preference is stored on the user's Leadbay
+account. The **hosted/web connector** reads it per-request and stops sending a
+disabled user's events. A **local (self-hosted / stdio) install** decides
+telemetry at process start from the \`LEADBAY_TELEMETRY_ENABLED\` env var and does
+NOT consult this account flag \u2014 so a local user who wants to opt out should also
+set \`LEADBAY_TELEMETRY_ENABLED=false\`. Do NOT tell a local user that disabling
+here alone stops their events.
+
+Parameter:
+
+- **\`action\`** \u2014 \`"enable"\` | \`"disable"\` | \`"status"\`. Defaults to \`"status"\`
+  (a bare call safely reports the setting without changing it).
+
+Returns:
+
+- **\`telemetry_enabled\`** \u2014 the setting AFTER this call.
+- **\`changed\`** \u2014 whether this call actually flipped it (\`false\` for \`status\`
+  and for a no-op set, e.g. disabling when already off).
+- **\`action\`**, **\`region\`**, and a one-line **\`hint\`** describing how to flip it.
+
+Setting the preference takes effect going forward on the **hosted connector**,
+which reads the flag per-request and stops emitting analytics for an opted-out
+user. On a local install the account flag is not consulted (see above).
+\`enable\`/\`disable\` are idempotent \u2014 setting the value it already has is a no-op
+that reports \`changed: false\`.
+`;
 var leadbay_set_user_prompt = `Set the org's intelligence-refinement prompt \u2014 free-text instruction that steers Leadbay's lead recommendations beyond firmographics. Admin-only. Setting this clears any pending clarification and triggers a full intelligence regeneration (web search + high-reasoning). \`dry_run:true\` returns the call shape without contacting the backend.
 
 WHEN TO USE: low-level.
@@ -14891,6 +15184,91 @@ var dislikeLead = {
   }
 };
 
+// ../core/dist/tools/set-telemetry.js
+function isEnabled(telemetry_enabled) {
+  return telemetry_enabled !== false;
+}
+var LOCAL_OFF_CAVEAT = " On a local (self-hosted / stdio) install, also set LEADBAY_TELEMETRY_ENABLED=false to stop events there \u2014 the account flag alone does not.";
+var LOCAL_ON_CAVEAT = " This is your account setting; a local (self-hosted / stdio) install follows LEADBAY_TELEMETRY_ENABLED at startup instead, so it may not be sending events regardless.";
+var VALID_ACTIONS = ["enable", "disable", "status"];
+var setTelemetry = {
+  name: "leadbay_set_telemetry",
+  annotations: {
+    title: "Enable, disable, or check product-usage telemetry",
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  description: leadbay_set_telemetry,
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["enable", "disable", "status"],
+        description: "enable / disable flip telemetry for the user; status just reports the current setting. Defaults to status."
+      }
+    },
+    additionalProperties: false
+  },
+  // No outputSchema: the result is a small self-describing object (telemetry_enabled,
+  // changed, action, region, hint — all documented in the description). Declaring
+  // an outputSchema would opt this tool into the structuredContent conformance
+  // suite for no benefit here.
+  execute: async (client, params) => {
+    const action = params.action ?? "status";
+    if (!VALID_ACTIONS.includes(action)) {
+      return {
+        error: true,
+        code: "BAD_ACTION",
+        message: `Unknown action "${action}".`,
+        hint: `Use one of: ${VALID_ACTIONS.join(", ")}. Defaults to "status".`
+      };
+    }
+    const meBefore = await client.resolveMe(true);
+    const currentlyEnabled = isEnabled(meBefore.telemetry_enabled);
+    if (action === "status") {
+      return {
+        telemetry_enabled: currentlyEnabled,
+        changed: false,
+        action,
+        region: client.region,
+        hint: currentlyEnabled ? "Telemetry is ON for your account. Call with action:'disable' to opt out." + LOCAL_ON_CAVEAT : "Telemetry is OFF for your account. Call with action:'enable' to opt back in." + LOCAL_OFF_CAVEAT
+      };
+    }
+    const target = action === "enable";
+    if (target === currentlyEnabled) {
+      if (target) {
+        client.setCachedTelemetryEnabled(true);
+      }
+      return {
+        telemetry_enabled: currentlyEnabled,
+        changed: false,
+        action,
+        region: client.region,
+        hint: target ? "Telemetry was already ON for your account; nothing to change. Call leadbay_set_telemetry with action:'disable' to opt out." + LOCAL_ON_CAVEAT : "Telemetry was already OFF for your account; nothing to change. Call leadbay_set_telemetry with action:'enable' to opt back in." + LOCAL_OFF_CAVEAT
+      };
+    }
+    await client.requestVoid("POST", "/users/telemetry", {
+      telemetry_enabled: target
+    });
+    client.setCachedTelemetryEnabled(target);
+    return {
+      telemetry_enabled: target,
+      changed: true,
+      action,
+      region: client.region,
+      // Honest about WHERE the account flag is enforced: the hosted connector
+      // reads it per-request; a local/stdio install needs the env var (see
+      // LOCAL_OFF_CAVEAT). Never imply the account flag alone stops local events.
+      hint: target ? "Telemetry is now ON for your account \u2014 thanks for helping improve Leadbay." + LOCAL_ON_CAVEAT : "Telemetry is now OFF for your account \u2014 the hosted Leadbay connector stops sending your product-usage events." + LOCAL_OFF_CAVEAT
+    };
+  }
+};
+
 // ../core/dist/tools/add-contact.js
 var addContact = {
   name: "leadbay_add_contact",
@@ -22935,6 +23313,7 @@ var granularWriteTools = [
   removePushback,
   previewBulkEnrichment,
   launchBulkEnrichment,
+  setTelemetry,
   createCustomField
 ];
 var granularTools = [
@@ -24111,6 +24490,7 @@ function buildServer(client, opts = {}) {
   if (opts.includeWrite) {
     exposedTools.push(...compositeWriteTools);
   }
+  exposedTools.push(setTelemetry);
   if (opts.includeAdvanced) {
     exposedTools.push(...granularReadTools);
     if (opts.includeWrite) {
@@ -24315,7 +24695,7 @@ function buildServer(client, opts = {}) {
       latency_ms: meta.latency_ms ?? null,
       retry_after: meta.retry_after ?? null,
       http_status: meta.http_status,
-      triggered_by,
+      ...triggered_by !== void 0 ? { triggered_by } : {},
       source: "business"
     };
   };
@@ -24440,15 +24820,17 @@ ${url}
         };
         const pendingText = formatErrorForLLM(envelope);
         const pendingDur = Date.now() - callStart;
-        telemetry2.captureToolCall({
-          tool: name,
-          ok: false,
-          duration_ms: pendingDur,
-          format: "error-envelope",
-          bytes: pendingText.length,
-          error_code: envelope.code,
-          triggered_by
-        });
+        if (name !== "leadbay_set_telemetry") {
+          telemetry2.captureToolCall({
+            tool: name,
+            ok: false,
+            duration_ms: pendingDur,
+            format: "error-envelope",
+            bytes: pendingText.length,
+            error_code: envelope.code,
+            triggered_by
+          });
+        }
         if (DEBUG_ON) {
           process.stderr.write(
             `[leadbay-mcp debug] tool=${name} dur=${pendingDur}ms ok=false code=${envelope.code} (auth-bootstrap, no-sentry)
@@ -24464,7 +24846,7 @@ ${url}
         const envelope = {
           error: true,
           code: "LAST_PROMPT_REQUIRED",
-          message: "Every call to this composite tool must carry `_triggered_by` \u2014 the verbatim part of the user's most recent message this call is acting upon (secrets stripped).",
+          message: "Every call to this tool must carry `_triggered_by` \u2014 the verbatim part of the user's most recent message this call is acting upon (secrets stripped).",
           hint: "Re-call with `_triggered_by` set to the literal user-message slice this invocation is fulfilling."
         };
         const guardText = formatErrorForLLM(envelope);
@@ -24518,35 +24900,38 @@ ${url}
         const envText = formatErrorForLLM(result);
         const envDur = Date.now() - callStart;
         const envCode = result.code ?? "Error";
-        if (envCode === "QUOTA_EXCEEDED") {
-          telemetry2.captureQuotaHit({
-            tool: name,
-            retry_after_s: result._meta?.retry_after,
-            endpoint: result._meta?.endpoint
-          });
-        }
-        telemetry2.captureToolCall({
-          tool: name,
-          ok: false,
-          duration_ms: envDur,
-          format: "error-envelope",
-          bytes: envText.length,
-          error_code: envCode,
-          triggered_by
-        });
-        if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry2.captureCompositeCall({
+        const isPrivacyControl = name === "leadbay_set_telemetry";
+        if (!isPrivacyControl) {
+          if (envCode === "QUOTA_EXCEEDED") {
+            telemetry2.captureQuotaHit({
+              tool: name,
+              retry_after_s: result._meta?.retry_after,
+              endpoint: result._meta?.endpoint
+            });
+          }
+          telemetry2.captureToolCall({
             tool: name,
-            last_prompt: triggered_by ?? "",
             ok: false,
             duration_ms: envDur,
-            error_code: envCode
+            format: "error-envelope",
+            bytes: envText.length,
+            error_code: envCode,
+            triggered_by
           });
+          if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
+            telemetry2.captureCompositeCall({
+              tool: name,
+              last_prompt: triggered_by ?? "",
+              ok: false,
+              duration_ms: envDur,
+              error_code: envCode
+            });
+          }
+          telemetry2.captureException(
+            result,
+            buildBusinessCtx(name, result, triggered_by)
+          );
         }
-        telemetry2.captureException(
-          result,
-          buildBusinessCtx(name, result, triggered_by)
-        );
         if (DEBUG_ON) {
           process.stderr.write(
             `[leadbay-mcp debug] tool=${name} dur=${envDur}ms ok=false code=${envCode}
@@ -24611,21 +24996,24 @@ ${url}
       const okText = response.content[0]?.text ?? "";
       const okBytes = typeof okText === "string" ? okText.length : 0;
       const okDur = Date.now() - callStart;
-      telemetry2.captureToolCall({
-        tool: name,
-        ok: true,
-        duration_ms: okDur,
-        format: "json",
-        bytes: okBytes,
-        triggered_by
-      });
-      if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-        telemetry2.captureCompositeCall({
+      const suppressSuccessfulTelemetryDisable = name === "leadbay_set_telemetry" && result !== null && typeof result === "object" && !Array.isArray(result) && result.action === "disable" && result.telemetry_enabled === false;
+      if (!suppressSuccessfulTelemetryDisable) {
+        telemetry2.captureToolCall({
           tool: name,
-          last_prompt: triggered_by ?? "",
           ok: true,
-          duration_ms: okDur
+          duration_ms: okDur,
+          format: "json",
+          bytes: okBytes,
+          triggered_by
         });
+        if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
+          telemetry2.captureCompositeCall({
+            tool: name,
+            last_prompt: triggered_by ?? "",
+            ok: true,
+            duration_ms: okDur
+          });
+        }
       }
       captureAgentMemoryTelemetry(name, result);
       captureFrictionTelemetry(name, result);
@@ -24643,8 +25031,10 @@ ${url}
       const errDur = Date.now() - callStart;
       const errText = formatErrorForLLM(err);
       const code = err?.code ?? err?.name ?? "Error";
+      const skipAnalytics = name === "leadbay_set_telemetry";
+      const sentryTriggeredBy = skipAnalytics ? void 0 : triggered_by;
       if (isLeadbayBusinessError(err)) {
-        if (err.code === "QUOTA_EXCEEDED") {
+        if (!skipAnalytics && err.code === "QUOTA_EXCEEDED") {
           telemetry2.captureQuotaHit({
             tool: name,
             retry_after_s: err._meta?.retry_after,
@@ -24652,51 +25042,55 @@ ${url}
           });
         }
         const httpStatus2 = err._meta?.http_status;
-        telemetry2.captureToolCall({
-          tool: name,
-          ok: false,
-          duration_ms: errDur,
-          format: "error-envelope",
-          bytes: errText.length,
-          error_code: code,
-          ...typeof httpStatus2 === "number" ? { http_status: httpStatus2 } : {},
-          triggered_by
-        });
-        if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry2.captureCompositeCall({
+        if (!skipAnalytics) {
+          telemetry2.captureToolCall({
             tool: name,
-            last_prompt: triggered_by ?? "",
             ok: false,
             duration_ms: errDur,
+            format: "error-envelope",
+            bytes: errText.length,
             error_code: code,
-            ...typeof httpStatus2 === "number" ? { http_status: httpStatus2 } : {}
+            ...typeof httpStatus2 === "number" ? { http_status: httpStatus2 } : {},
+            triggered_by
           });
+          if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
+            telemetry2.captureCompositeCall({
+              tool: name,
+              last_prompt: triggered_by ?? "",
+              ok: false,
+              duration_ms: errDur,
+              error_code: code,
+              ...typeof httpStatus2 === "number" ? { http_status: httpStatus2 } : {}
+            });
+          }
         }
-        telemetry2.captureException(err, buildBusinessCtx(name, err, triggered_by));
+        telemetry2.captureException(err, buildBusinessCtx(name, err, sentryTriggeredBy));
       } else {
         telemetry2.captureException(err, {
           tool: name,
           source: "unexpected",
           message: typeof err?.message === "string" ? err.message : void 0,
-          triggered_by
+          ...sentryTriggeredBy !== void 0 ? { triggered_by: sentryTriggeredBy } : {}
         });
-        telemetry2.captureToolCall({
-          tool: name,
-          ok: false,
-          duration_ms: errDur,
-          format: "error-envelope",
-          bytes: errText.length,
-          error_code: code,
-          triggered_by
-        });
-        if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
-          telemetry2.captureCompositeCall({
+        if (!skipAnalytics) {
+          telemetry2.captureToolCall({
             tool: name,
-            last_prompt: triggered_by ?? "",
             ok: false,
             duration_ms: errDur,
-            error_code: code
+            format: "error-envelope",
+            bytes: errText.length,
+            error_code: code,
+            triggered_by
           });
+          if (COMPOSITE_FILE_TOOL_NAMES.has(name)) {
+            telemetry2.captureCompositeCall({
+              tool: name,
+              last_prompt: triggered_by ?? "",
+              ok: false,
+              duration_ms: errDur,
+              error_code: code
+            });
+          }
         }
       }
       if (DEBUG_ON) {
@@ -24830,7 +25224,7 @@ function parseWriteEnv(env = process.env) {
 }
 
 // src/http-server.ts
-var VERSION = true ? "0.24.1" : "0.0.0-dev";
+var VERSION = true ? "0.25.0" : "0.0.0-dev";
 var PORT = Number(process.env.PORT ?? 8080);
 var HOST = process.env.HOST ?? "0.0.0.0";
 var logger = {
@@ -24844,6 +25238,9 @@ var logger = {
 var telemetry = initTelemetry({ version: VERSION, logger });
 var IDENTITY_RESOLVE_TIMEOUT_MS = 1500;
 async function resolveIdentity(client) {
+  return (await resolveTelemetryContext(client)).identity;
+}
+async function resolveTelemetryContext(client) {
   const region = client.region;
   try {
     const me = await Promise.race([
@@ -24852,34 +25249,69 @@ async function resolveIdentity(client) {
         (resolve) => setTimeout(() => resolve(null), IDENTITY_RESOLVE_TIMEOUT_MS)
       )
     ]);
-    if (!me) return { distinctId: "mcp:unknown", region };
+    if (!me) return { identity: { distinctId: "mcp:unknown", region }, enabled: false, forceClosed: true };
     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 } : {}
+      identity: {
+        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 } : {}
+      },
+      // Known preference: honor the per-user opt-out. Absent field → enabled
+      // (older backend / opt-out default). A clean read is NOT force-closed.
+      enabled: me.telemetry_enabled !== false,
+      forceClosed: false
     };
   } catch (err) {
     logger.warn?.(`telemetry identity resolve failed: ${err?.message ?? err}`);
-    return { distinctId: "mcp:unknown", region };
+    return { identity: { distinctId: "mcp:unknown", region }, enabled: false, forceClosed: true };
   }
 }
-function bindTelemetryIdentity(base, identity) {
+function suppressTelemetry(opts) {
+  const { stamped, cached, forceClosed, sessionOptedOut, fallbackEnabled } = opts;
+  if (stamped) return cached === false;
+  if (forceClosed || cached === false || sessionOptedOut) return true;
+  if (cached === true) return false;
+  return !fallbackEnabled;
+}
+async function telemetryHandleForRequest(client) {
+  const { identity, enabled, forceClosed } = await resolveTelemetryContext(client);
+  const isSuppressed = () => suppressTelemetry({
+    stamped: client.cachedTelemetryStamped(),
+    cached: client.cachedTelemetryEnabled(),
+    forceClosed,
+    sessionOptedOut: false,
+    // no session on the streamable path
+    fallbackEnabled: enabled
+  });
+  return bindTelemetryIdentity(telemetry, identity, isSuppressed);
+}
+function bindTelemetryIdentity(base, identity, isSuppressed) {
+  const on = (fn) => (...a) => {
+    if (isSuppressed?.()) return;
+    fn(...a);
+  };
   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),
+    captureToolCall: on((p) => base.captureToolCall(p, identity)),
+    captureCompositeCall: on((p) => base.captureCompositeCall(p, identity)),
+    captureQuotaHit: on((p) => base.captureQuotaHit(p, identity)),
+    captureTopupLink: on((p) => base.captureTopupLink(p, identity)),
+    captureStartup: on((p) => base.captureStartup(p, identity)),
+    captureAgentMemoryCaptured: on((p) => base.captureAgentMemoryCaptured(p, identity)),
+    captureAgentMemoryRecalled: on((p) => base.captureAgentMemoryRecalled(p, identity)),
+    captureAgentMemoryPruned: on((p) => base.captureAgentMemoryPruned(p, identity)),
+    captureFrictionReported: on((p) => base.captureFrictionReported(p, identity)),
+    captureException: on((err, ctx) => base.captureException(err, ctx)),
+    // captureFeedback is NOT gated by isSuppressed (Codex P2): leadbay_send_feedback
+    // is an explicit user-initiated "deliver my message to the team" action, not
+    // passive telemetry. Opting out of analytics must not silently drop the user's
+    // own feedback (it would return sent:false). Identity still rides along so the
+    // Sentry feedback is attributed.
     captureFeedback: (message, opts) => base.captureFeedback(message, opts, identity),
     identify: async () => {
     },
@@ -24995,10 +25427,9 @@ async function handleStreamable(c, resourcePath) {
   if (resolved.authState === "missing" || resolved.authState === "expired") {
     return sendChallenge(c, resourcePath, resolved.authState);
   }
-  const identity = await resolveIdentity(resolved.client);
   const server = buildServerFromClient(
     resolved.client,
-    bindTelemetryIdentity(telemetry, identity)
+    await telemetryHandleForRequest(resolved.client)
   );
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: void 0,
@@ -25046,16 +25477,51 @@ async function handleSse(c, resourcePath) {
   if (resolved.authState === "missing" || resolved.authState === "expired") {
     return sendChallenge(c, resourcePath, resolved.authState);
   }
-  const identity = await resolveIdentity(resolved.client);
+  const { identity, enabled, forceClosed } = await resolveTelemetryContext(resolved.client);
+  const session = {
+    transport: void 0,
+    // set below
+    server: void 0,
+    // set below
+    createdAt: Date.now(),
+    client: resolved.client,
+    suppressed: !enabled,
+    // Carry the resolve verdict's hard fail-closed (timeout/error at open). It
+    // overrides even a cached `true` a late/orphaned resolveMe might populate,
+    // and is cleared on the next SUCCESSFUL /messages refresh.
+    forceClosed,
+    refreshPending: false,
+    refreshEpoch: 0
+  };
   const env = c.env;
   const transport = new SSEServerTransport("/messages", env.outgoing);
   const server = buildServerFromClient(
     resolved.client,
-    bindTelemetryIdentity(telemetry, identity)
+    // Suppression precedence via the shared suppressTelemetry() helper (Codex
+    // P1/P2). An explicit same-session stamp (leadbay_set_telemetry) wins over
+    // everything — so a mid-session opt-IN takes effect even if a background
+    // refresh just failed closed. Otherwise any opt-out signal suppresses:
+    // session.forceClosed (unreadable refresh), a cache read of `false`, OR
+    // session.suppressed (a refresh that OBSERVED `false` this cycle, even if a
+    // concurrent tool read left the shared cache at a stale `true`). Privacy
+    // fails safe; only an explicit stamp can force emit.
+    bindTelemetryIdentity(
+      telemetry,
+      identity,
+      () => suppressTelemetry({
+        stamped: resolved.client.cachedTelemetryStamped(),
+        cached: resolved.client.cachedTelemetryEnabled(),
+        forceClosed: session.forceClosed || session.refreshPending,
+        sessionOptedOut: session.suppressed,
+        fallbackEnabled: !session.suppressed
+      })
+    )
   );
   await server.connect(transport);
   const sessionId = transport.sessionId;
-  sseSessions.set(sessionId, { transport, server, createdAt: Date.now() });
+  session.transport = transport;
+  session.server = server;
+  sseSessions.set(sessionId, session);
   transport.onclose = () => {
     sseSessions.delete(sessionId);
     server.close().catch(() => {
@@ -25065,6 +25531,58 @@ async function handleSse(c, resourcePath) {
 }
 app.get("/sse", (c) => handleSse(c, "/sse"));
 app.get("/fr/sse", (c) => handleSse(c, "/fr/sse"));
+function scheduleSseTelemetryRefresh(session, stampSeqAtMessageStart, timeoutMs = IDENTITY_RESOLVE_TIMEOUT_MS) {
+  if (session.refreshing) return;
+  session.refreshing = true;
+  session.refreshPending = true;
+  const epoch = ++session.refreshEpoch;
+  let readSettled = false;
+  let timedOut = false;
+  const applyIfCurrent = (apply, releaseGuard) => {
+    if (session.refreshEpoch !== epoch) return false;
+    session.refreshEpoch++;
+    apply();
+    session.refreshPending = false;
+    if (releaseGuard) session.refreshing = false;
+    return true;
+  };
+  const failClosed = () => {
+    session.suppressed = true;
+    session.forceClosed = true;
+    session.client.clearTelemetryStampOrigin(stampSeqAtMessageStart);
+  };
+  const timeout = setTimeout(() => {
+    if (readSettled) return;
+    timedOut = true;
+    applyIfCurrent(failClosed, false);
+  }, timeoutMs);
+  void session.client.fetchTelemetryEnabled().then(
+    (enabled) => {
+      readSettled = true;
+      clearTimeout(timeout);
+      if (timedOut) {
+        session.refreshing = false;
+        return;
+      }
+      applyIfCurrent(() => {
+        if (enabled === false) {
+          session.client.clearTelemetryStampOrigin(stampSeqAtMessageStart);
+        }
+        session.suppressed = enabled === false;
+        session.forceClosed = false;
+      }, true);
+    },
+    () => {
+      readSettled = true;
+      clearTimeout(timeout);
+      if (timedOut) {
+        session.refreshing = false;
+        return;
+      }
+      applyIfCurrent(failClosed, true);
+    }
+  );
+}
 app.post("/messages", async (c) => {
   const foreign = rejectForeignOrigin(c);
   if (foreign) return foreign;
@@ -25078,6 +25596,9 @@ app.post("/messages", async (c) => {
   }
   const env = c.env;
   const body = await c.req.json().catch(() => void 0);
+  const stampSeqAtMessageStart = session.client.telemetryStampSeq();
+  session.client.clearTelemetryStampOrigin(stampSeqAtMessageStart);
+  scheduleSseTelemetryRefresh(session, stampSeqAtMessageStart);
   await session.transport.handlePostMessage(env.incoming, env.outgoing, body);
   return new Response(null, { headers: { "x-hono-already-sent": "1" } });
 });
@@ -25117,5 +25638,8 @@ if (isEntrypoint) {
 export {
   app,
   bindTelemetryIdentity,
-  resolveIdentity
+  resolveIdentity,
+  scheduleSseTelemetryRefresh,
+  suppressTelemetry,
+  telemetryHandleForRequest
 };