@leadbay/mcp 0.2.0

package/dist/chunk-BGJ6JWIO.js

@@ -0,0 +1,3010 @@
+#!/usr/bin/env node
+
+// ../core/dist/client.js
+import https from "https";
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+var LENS_CACHE_TTL_MS = 5 * 60 * 1e3;
+var TASTE_CACHE_TTL_MS = 10 * 60 * 1e3;
+var ME_CACHE_TTL_MS = 60 * 1e3;
+var MAX_CONCURRENT = 5;
+var REGIONS = {
+  us: "https://api-us.leadbay.app",
+  fr: "https://api-fr.leadbay.app"
+};
+function httpsRequest(method, url, headers, body) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const parsed = new URL(url);
+    const reqHeaders = { ...headers };
+    if (body) {
+      reqHeaders["Content-Length"] = Buffer.byteLength(body);
+    }
+    const req = https.request({
+      hostname: parsed.hostname,
+      port: 443,
+      path: parsed.pathname + parsed.search,
+      method,
+      headers: reqHeaders
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        resolve({
+          status: res.statusCode ?? 0,
+          body: Buffer.concat(chunks).toString("utf8"),
+          headers: res.headers,
+          latency_ms: Date.now() - start
+        });
+      });
+    });
+    req.on("error", reject);
+    if (body)
+      req.write(body);
+    req.end();
+  });
+}
+function createClient(config = {}) {
+  const region = config.region ?? "us";
+  const baseUrl = config.baseUrl ?? REGIONS[region];
+  if (!baseUrl) {
+    throw new Error(`Leadbay: unknown region "${region}". Supported: ${Object.keys(REGIONS).join(", ")}. Or pass an explicit baseUrl.`);
+  }
+  return new LeadbayClient(baseUrl, config.token, region);
+}
+async function resolveRegion(email, password, startWith = "us") {
+  const order = startWith === "fr" ? ["fr", "us"] : ["us", "fr"];
+  let lastErr = null;
+  for (const region of order) {
+    const baseUrl = REGIONS[region];
+    const body = JSON.stringify({ email, password });
+    try {
+      const res = await httpsRequest("POST", `${baseUrl}/1.5/auth/login`, { "Content-Type": "application/json" }, body);
+      if (res.status === 200) {
+        const parsed = JSON.parse(res.body);
+        if (parsed?.token) {
+          return {
+            region,
+            baseUrl,
+            token: parsed.token,
+            verified: parsed.verified === true
+          };
+        }
+      }
+      lastErr = { status: res.status, body: res.body, region };
+    } catch (e) {
+      lastErr = { error: e, region };
+    }
+  }
+  throw new Error(`Leadbay login failed in both regions (us, fr). Last response: ${JSON.stringify(lastErr)}`);
+}
+var _mockFixtures = null;
+var _mockJournal = [];
+function loadMockFixtures(dir) {
+  if (!existsSync(dir))
+    return [];
+  const out = [];
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith(".json"))
+      continue;
+    try {
+      const raw = readFileSync(join(dir, f), "utf8");
+      const parsed = JSON.parse(raw);
+      if (!parsed.request || !parsed.response)
+        continue;
+      const url = parsed.request.url ?? "";
+      const u = new URL(url);
+      out.push({
+        method: parsed.request.method ?? "GET",
+        path: u.pathname + u.search,
+        status: parsed.response.status,
+        body: parsed.response.body,
+        headers: parsed.response.headers ?? {}
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+function ensureMockLoaded() {
+  if (_mockFixtures !== null)
+    return;
+  const dir = process.env.LEADBAY_MOCK_DIR ?? join(process.cwd(), ".context", "leadbay-live-shapes");
+  _mockFixtures = loadMockFixtures(dir);
+  if (process.env.LEADBAY_MOCK === "1") {
+    process.stderr.write(`[leadbay mock] loaded ${_mockFixtures.length} fixtures from ${dir}
+`);
+  }
+}
+function findMockFixture(method, basePath) {
+  ensureMockLoaded();
+  if (!_mockFixtures)
+    return null;
+  for (const f of _mockFixtures) {
+    if (f.method !== method)
+      continue;
+    if (basePath === f.path)
+      return f;
+    const fNoQs = f.path.split("?")[0];
+    const bNoQs = basePath.split("?")[0];
+    if (fNoQs === bNoQs)
+      return f;
+  }
+  return null;
+}
+function getMockJournal() {
+  return _mockJournal;
+}
+function clearMockJournal() {
+  _mockJournal = [];
+}
+var LeadbayClient = class {
+  token;
+  _baseUrl;
+  _region;
+  defaultLensId = null;
+  defaultLensCachedAt = null;
+  mePayload = null;
+  mePayloadCachedAt = null;
+  tasteProfile = null;
+  tasteProfileCachedAt = null;
+  // Simple semaphore for concurrency limiting.
+  activeRequests = 0;
+  waitQueue = [];
+  // Selection-state Mutex. The /leads/selection/* endpoints share global
+  // server-side state per token, so two parallel composites that each call
+  // select → action → clear would clobber each other. Composites that touch
+  // selection acquire this lock for the lifetime of their select…clear cycle.
+  selectionLockHeld = false;
+  selectionWaitQueue = [];
+  // Last response metadata — composites can read this after a request to
+  // surface latency/region/retry_after to the agent in their `_meta` block.
+  _lastMeta = null;
+  constructor(baseUrl, token, region) {
+    this._baseUrl = baseUrl.replace(/\/+$/, "");
+    this.token = token ?? null;
+    this._region = region ?? (baseUrl === REGIONS.us ? "us" : baseUrl === REGIONS.fr ? "fr" : "custom");
+  }
+  get baseUrl() {
+    return this._baseUrl;
+  }
+  get region() {
+    return this._region;
+  }
+  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");
+    this.defaultLensId = null;
+    this.defaultLensCachedAt = null;
+    this.mePayload = null;
+    this.mePayloadCachedAt = null;
+    this.tasteProfile = null;
+    this.tasteProfileCachedAt = null;
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  get isAuthenticated() {
+    return this.token !== null;
+  }
+  // Test-only getter for concurrency assertions
+  get _semaphoreState() {
+    return { active: this.activeRequests, queued: this.waitQueue.length };
+  }
+  async acquireSemaphore() {
+    if (this.activeRequests < MAX_CONCURRENT) {
+      this.activeRequests++;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waitQueue.push(() => {
+        this.activeRequests++;
+        resolve();
+      });
+    });
+  }
+  releaseSemaphore() {
+    this.activeRequests--;
+    const next = this.waitQueue.shift();
+    if (next)
+      next();
+  }
+  // Selection Mutex — composites that touch /leads/selection/* must wrap
+  // their select…clear cycle in acquire/release to avoid clobbering across
+  // concurrent invocations.
+  async acquireSelectionLock() {
+    if (!this.selectionLockHeld) {
+      this.selectionLockHeld = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.selectionWaitQueue.push(() => {
+        this.selectionLockHeld = true;
+        resolve();
+      });
+    });
+  }
+  releaseSelectionLock() {
+    this.selectionLockHeld = false;
+    const next = this.selectionWaitQueue.shift();
+    if (next)
+      next();
+  }
+  async request(method, path, body) {
+    if (process.env.LEADBAY_MOCK === "1") {
+      return this.mockRequest(method, path, body);
+    }
+    if (!this.token) {
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN env var (obtain token at https://app.leadbay.ai/settings/api-tokens), or use the OpenClaw leadbay_login tool", path);
+    }
+    await this.acquireSemaphore();
+    try {
+      const url = `${this._baseUrl}/1.5${path}`;
+      const headers = {
+        Authorization: `Bearer ${this.token}`
+      };
+      if (body) {
+        headers["Content-Type"] = "application/json";
+      }
+      const res = await httpsRequest(method, url, headers, body ? JSON.stringify(body) : void 0);
+      this._lastMeta = {
+        region: this._region,
+        endpoint: `${method} ${path}`,
+        latency_ms: res.latency_ms,
+        retry_after: parseRetryAfter(res.headers["retry-after"])
+      };
+      if (res.status === 204) {
+        return null;
+      }
+      if (res.status < 200 || res.status >= 300) {
+        throw this.mapErrorResponse(res.status, res.body, path, res.headers);
+      }
+      return JSON.parse(res.body);
+    } finally {
+      this.releaseSemaphore();
+    }
+  }
+  async requestVoid(method, path, body) {
+    if (process.env.LEADBAY_MOCK === "1") {
+      await this.mockRequest(method, path, body);
+      return;
+    }
+    if (!this.token) {
+      throw this.makeError("NOT_AUTHENTICATED", "Not logged in to Leadbay", "Set LEADBAY_TOKEN env var (obtain token at https://app.leadbay.ai/settings/api-tokens), or use the OpenClaw leadbay_login tool", path);
+    }
+    await this.acquireSemaphore();
+    try {
+      const url = `${this._baseUrl}/1.5${path}`;
+      const headers = {
+        Authorization: `Bearer ${this.token}`
+      };
+      if (body) {
+        headers["Content-Type"] = "application/json";
+      }
+      const res = await httpsRequest(method, url, headers, body ? JSON.stringify(body) : void 0);
+      this._lastMeta = {
+        region: this._region,
+        endpoint: `${method} ${path}`,
+        latency_ms: res.latency_ms,
+        retry_after: parseRetryAfter(res.headers["retry-after"])
+      };
+      if (res.status < 200 || res.status >= 300) {
+        throw this.mapErrorResponse(res.status, res.body, path, res.headers);
+      }
+    } finally {
+      this.releaseSemaphore();
+    }
+  }
+  mockRequest(method, path, body) {
+    const fullPath = `/1.5${path}`;
+    this._lastMeta = {
+      region: this._region,
+      endpoint: `${method} ${path}`,
+      latency_ms: 0,
+      retry_after: null
+    };
+    if (method === "GET") {
+      const fixture = findMockFixture("GET", fullPath);
+      if (!fixture) {
+        throw this.makeError("MOCK_NOT_FOUND", `LEADBAY_MOCK=1: no fixture for GET ${path}`, `Add a fixture to LEADBAY_MOCK_DIR (default: ./.context/leadbay-live-shapes/) \u2014 run a probe script to generate one.`, path);
+      }
+      if (fixture.status === 204)
+        return null;
+      return fixture.body;
+    }
+    _mockJournal.push({ method, path: fullPath, body, ts: Date.now() });
+    return {
+      mocked: true,
+      would_call: { method, path: fullPath, body }
+    };
+  }
+  mapErrorResponse(status, rawBody, endpoint, headers) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawBody);
+    } catch {
+      parsed = null;
+    }
+    const retryAfter = parseRetryAfter(headers["retry-after"]);
+    if (status === 401) {
+      return this.makeError("AUTH_EXPIRED", "Authentication token expired or invalid", "Your LEADBAY_TOKEN is no longer valid. Regenerate at https://app.leadbay.ai/settings/api-tokens and restart.", endpoint);
+    }
+    if (status === 429 || status === 402 || parsed?.error === "quota_exceeded" || parsed?.error?.code === "quota_exceeded") {
+      return this.makeError("QUOTA_EXCEEDED", retryAfter ? `Quota exceeded \u2014 retry in ${retryAfter}s` : "Quota exceeded", retryAfter ? `Wait ${retryAfter}s before retrying. Check leadbay_get_quota to see which resource window was hit.` : "Wait, then retry. Check leadbay_get_quota to see which resource window (daily/weekly/monthly) was hit.", endpoint, retryAfter);
+    }
+    if (status === 403) {
+      const msg = parsed?.message || parsed?.error || parsed?.error?.message || "";
+      if (typeof msg === "string" && (msg.includes("suspend") || msg.includes("billing"))) {
+        return this.makeError("BILLING_SUSPENDED", "Account billing is suspended", "Your Leadbay account billing is suspended. Update at https://app.leadbay.ai", endpoint);
+      }
+      return this.makeError("FORBIDDEN", "Insufficient permissions", "Your token does not have access to this resource. Check account permissions at https://app.leadbay.ai", endpoint);
+    }
+    if (status === 404) {
+      return this.makeError("NOT_FOUND", parsed?.message || parsed?.error?.message || "Resource not found", "Verify the ID is correct", endpoint);
+    }
+    return this.makeError("API_ERROR", parsed?.message || parsed?.error?.message || `API error (${status})`, "Try again or check the Leadbay API status", endpoint);
+  }
+  // /me cache (60s TTL). Separate from resolveOrgId() which still works for
+  // legacy callers (it now delegates here).
+  async resolveMe(force = false) {
+    const now = Date.now();
+    if (!force && this.mePayload !== null && this.mePayloadCachedAt !== null && now - this.mePayloadCachedAt < ME_CACHE_TTL_MS) {
+      return this.mePayload;
+    }
+    const me = await this.request("GET", "/users/me");
+    this.mePayload = me;
+    this.mePayloadCachedAt = now;
+    return me;
+  }
+  // Force re-fetch on next resolveMe(). Call from any tool that mutates a
+  // /me-cached field (last_requested_lens, billing, etc.).
+  invalidateMe() {
+    this.mePayload = null;
+    this.mePayloadCachedAt = null;
+  }
+  async resolveDefaultLens() {
+    const now = Date.now();
+    if (this.defaultLensId !== null && this.defaultLensCachedAt !== null && now - this.defaultLensCachedAt < LENS_CACHE_TTL_MS) {
+      return this.defaultLensId;
+    }
+    try {
+      const me = await this.resolveMe();
+      if (me.last_requested_lens != null) {
+        this.defaultLensId = me.last_requested_lens;
+        this.defaultLensCachedAt = now;
+        return this.defaultLensId;
+      }
+    } catch {
+    }
+    const lenses = await this.request("GET", "/lenses");
+    const active = lenses.find((l) => l.is_last_active);
+    const fallback = active || lenses.find((l) => l.is_default || l.default) || lenses[0];
+    if (!fallback) {
+      throw this.makeError("NO_LENS", "No lenses found on your account", "Open the Leadbay web UI once to provision your first lens, or create one via the API", "GET /lenses");
+    }
+    this.defaultLensId = fallback.id;
+    this.defaultLensCachedAt = now;
+    return this.defaultLensId;
+  }
+  invalidateDefaultLens() {
+    this.defaultLensId = null;
+    this.defaultLensCachedAt = null;
+  }
+  async resolveOrgId() {
+    const me = await this.resolveMe();
+    return me.organization.id;
+  }
+  async resolveTasteProfile() {
+    const now = Date.now();
+    if (this.tasteProfile !== null && this.tasteProfileCachedAt !== null && now - this.tasteProfileCachedAt < TASTE_CACHE_TTL_MS) {
+      return this.tasteProfile;
+    }
+    const orgId = await this.resolveOrgId();
+    const [ibpResult, tagsResult, questionsResult] = await Promise.allSettled([
+      this.request("GET", `/organizations/${orgId}/ideal_buyer_profile`),
+      this.request("GET", `/organizations/${orgId}/purchase_intent_tags`),
+      this.request("GET", `/organizations/${orgId}/ai_agent_questions`)
+    ]);
+    this.tasteProfile = {
+      idealBuyerProfile: ibpResult.status === "fulfilled" ? ibpResult.value : null,
+      purchaseIntentTags: tagsResult.status === "fulfilled" ? tagsResult.value : [],
+      qualificationQuestions: questionsResult.status === "fulfilled" ? questionsResult.value : []
+    };
+    this.tasteProfileCachedAt = now;
+    return this.tasteProfile;
+  }
+  invalidateTasteProfile() {
+    this.tasteProfile = null;
+    this.tasteProfileCachedAt = null;
+  }
+  async prefetchOrgData() {
+    await this.resolveOrgId();
+    await this.resolveTasteProfile();
+  }
+  makeError(code, message, hint, endpoint, retry_after) {
+    const out = { error: true, code, message, hint };
+    if (endpoint || this._region) {
+      out._meta = {
+        region: this._region,
+        endpoint: endpoint ?? "",
+        latency_ms: this._lastMeta?.latency_ms ?? null,
+        retry_after: retry_after ?? null
+      };
+    }
+    return out;
+  }
+};
+function parseRetryAfter(value) {
+  if (!value)
+    return null;
+  const v = Array.isArray(value) ? value[0] : value;
+  const n = Number(v);
+  if (Number.isFinite(n))
+    return n;
+  const date = Date.parse(v);
+  if (Number.isFinite(date)) {
+    return Math.max(0, Math.round((date - Date.now()) / 1e3));
+  }
+  return null;
+}
+
+// ../core/dist/tools/login.js
+var login = {
+  name: "leadbay_login",
+  description: "Log in to Leadbay with email and password. Auto-detects region (us|fr) \u2014 the user does not need to know which backend their account lives on. When to use: at the start of a session if no token is preconfigured (cfg.token / LEADBAY_TOKEN). When NOT to use: if a token is already preconfigured (you'll just overwrite it). The user needs a Leadbay account \u2014 they can register at https://wow.leadbay.ai/?register=true",
+  inputSchema: {
+    type: "object",
+    properties: {
+      email: { type: "string", description: "Leadbay account email address" },
+      password: { type: "string", description: "Leadbay account password" }
+    },
+    required: ["email", "password"]
+  },
+  execute: async (client, params, ctx) => {
+    const cleanPassword = params.password.replace(/\\(.)/g, "$1");
+    const startWith = client.region === "fr" ? "fr" : "us";
+    ctx?.logger?.info?.(`LeadClaw login: email=${params.email} startRegion=${startWith}`);
+    try {
+      const result = await resolveRegion(params.email, cleanPassword, startWith);
+      if (client.baseUrl !== result.baseUrl) {
+        client.setBaseUrl(result.baseUrl, result.region);
+        ctx?.logger?.info?.(`LeadClaw login: switched to region=${result.region} (account is in the ${result.region.toUpperCase()} backend)`);
+      }
+      client.setToken(result.token);
+      client.prefetchOrgData().catch(() => {
+      });
+      return {
+        success: true,
+        message: `Logged in to Leadbay (${result.region.toUpperCase()})`,
+        region: result.region,
+        verified: result.verified
+      };
+    } catch (err) {
+      ctx?.logger?.error?.(`LeadClaw login: failed: ${err?.message}`);
+      return {
+        error: true,
+        code: "LOGIN_FAILED",
+        message: err?.message || "Login failed in both regions",
+        hint: `Check your email and password. The auto-detect tried both ${REGIONS.us} and ${REGIONS.fr}. Need an account? Register at https://wow.leadbay.ai/?register=true`
+      };
+    }
+  }
+};
+
+// ../core/dist/tools/list-lenses.js
+var listLenses = {
+  name: "leadbay_list_lenses",
+  description: "List all available Leadbay lenses (saved lead search configurations). Each lens defines a different target market or buyer segment. The lens with is_last_active=true is used by default for lead discovery. When to use: when the user wants to switch lens or asks 'what lenses do I have'. When NOT to use: in normal flow \u2014 composites auto-resolve the active lens via /me.last_requested_lens.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  execute: async (client) => {
+    const lenses = await client.request("GET", "/lenses");
+    return {
+      lenses: lenses.map((l) => ({
+        id: l.id,
+        name: l.name,
+        is_last_active: l.is_last_active,
+        description: l.description
+      }))
+    };
+  }
+};
+
+// ../core/dist/tools/discover-leads.js
+var discoverLeads = {
+  name: "leadbay_discover_leads",
+  description: "Get AI-recommended leads from Leadbay. Returns paginated lead summaries with scores, AI summaries, tags, and recommended contacts. When to use: low-level when you need raw paginated wishlist access without the qualification_summary attached by leadbay_pull_leads. When NOT to use: as the agent's default lead-discovery entry point \u2014 use leadbay_pull_leads, which adds a one-line qualification summary per lead.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      lensId: {
+        type: "number",
+        description: "Lens ID (optional, auto-resolves to the active lens)"
+      },
+      page: {
+        type: "number",
+        description: "Page number, 0-indexed (default: 0)"
+      },
+      count: {
+        type: "number",
+        description: "Results per page, max 50 (default: 20)"
+      }
+    }
+  },
+  execute: async (client, params) => {
+    const lensId = params.lensId ?? await client.resolveDefaultLens();
+    const page = params.page ?? 0;
+    const count = Math.min(params.count ?? 20, 50);
+    const res = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=${count}&page=${page}&contacts=true`);
+    return {
+      leads: res.items.map((lead) => ({
+        id: lead.id,
+        name: lead.name,
+        score: lead.score,
+        ai_agent_lead_score: lead.ai_agent_lead_score,
+        location: lead.location,
+        description: lead.description,
+        size: lead.size,
+        website: lead.website,
+        contacts_count: lead.contacts_count,
+        ai_summary: lead.ai_summary,
+        split_ai_summary: lead.split_ai_summary,
+        tags: lead.tags,
+        phone_numbers: lead.phone_numbers,
+        keywords: lead.keywords,
+        recommended_contact_title: lead.recommended_contact_title ?? null,
+        recommended_contact: lead.recommended_contact ?? null
+      })),
+      pagination: res.pagination
+    };
+  }
+};
+
+// ../core/dist/tools/get-lead-profile.js
+var getLeadProfile = {
+  name: "leadbay_get_lead_profile",
+  description: "Get a full lead profile including company details, AI qualification scores, web insights, and contacts. When to use: low-level \u2014 for fine-grained access to the raw shape of the lead profile. When NOT to use: as the agent's default lead-detail tool \u2014 use leadbay_research_lead, which structures the data top-down (qualification first, then signals, then firmographics, then contacts, then engagement) and reshapes web_fetch.content into a stable array form.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      },
+      lensId: {
+        type: "number",
+        description: "Lens ID (optional, auto-resolves to active lens)"
+      }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    const lensId = params.lensId ?? await client.resolveDefaultLens();
+    const [leadResult, qualResult, contactsResult, paidContactsResult, webFetchResult] = await Promise.allSettled([
+      client.request("GET", `/lenses/${lensId}/leads/${params.leadId}`),
+      client.request("GET", `/leads/${params.leadId}/ai_agent_responses`),
+      client.request("GET", `/leads/${params.leadId}/contacts?IncludeEnriched=true`),
+      client.request("GET", `/leads/${params.leadId}/enrich/contacts?IncludeEnriched=true`),
+      client.request("GET", `/leads/${params.leadId}/web_fetch`)
+    ]);
+    if (leadResult.status === "rejected") {
+      throw leadResult.reason;
+    }
+    const lead = leadResult.value;
+    const qualification = qualResult.status === "fulfilled" ? qualResult.value : null;
+    const orgContacts = contactsResult.status === "fulfilled" ? contactsResult.value : [];
+    const paidContacts = paidContactsResult.status === "fulfilled" ? paidContactsResult.value : [];
+    const webFetch = webFetchResult.status === "fulfilled" ? webFetchResult.value : null;
+    const allContacts = [
+      ...orgContacts.map((c) => ({
+        id: c.id,
+        first_name: c.first_name,
+        last_name: c.last_name,
+        email: c.email,
+        phone_number: c.phone_number,
+        linkedin_page: c.linkedin_page,
+        job_title: c.job_title,
+        recommended: c.recommended,
+        enrichment: c.enrichment,
+        source: "org"
+      })),
+      ...paidContacts.map((c) => ({
+        id: c.id,
+        first_name: c.first_name,
+        last_name: c.last_name,
+        email: c.email,
+        phone_number: c.phone_number,
+        linkedin_page: c.linkedin_page,
+        job_title: c.job_title,
+        recommended: c.recommended,
+        enrichment: c.enrichment,
+        source: "paid"
+      }))
+    ];
+    return {
+      lead: {
+        id: lead.id,
+        name: lead.name,
+        score: lead.score,
+        ai_agent_lead_score: lead.ai_agent_lead_score,
+        location: lead.location,
+        description: lead.description,
+        short_description: lead.short_description,
+        size: lead.size,
+        website: lead.website,
+        logo: lead.logo,
+        ai_summary: lead.ai_summary,
+        split_ai_summary: lead.split_ai_summary,
+        tags: lead.tags,
+        phone_numbers: lead.phone_numbers,
+        keywords: lead.keywords,
+        contacts_count: lead.contacts_count,
+        recommended_contact_title: lead.recommended_contact_title ?? null,
+        recommended_contact: lead.recommended_contact ?? null,
+        web_fetch_in_progress: lead.web_fetch_in_progress ?? false
+      },
+      qualification: qualification?.map((q) => ({
+        question: q.question,
+        score: q.score,
+        response: q.response,
+        computed_at: q.computed_at,
+        outdated_at: q.outdated_at
+      })) ?? null,
+      contacts: allContacts,
+      web_insights: webFetch?.content ?? null,
+      web_insights_fetched_at: webFetch?.fetch_at ?? null
+    };
+  }
+};
+
+// ../core/dist/tools/get-contacts.js
+var getContacts = {
+  name: "leadbay_get_contacts",
+  description: "Get contacts for a lead, including enriched email and phone data. Returns both organization contacts and enrichable contacts with IDs. When to use: to check enrichment status (contact.enrichment.done) on individual leads after a bulk enrichment was launched, or to find the contact_id needed by leadbay_enrich_contacts. When NOT to use: as a substitute for leadbay_research_lead, which already includes enriched contacts in its return.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    const [orgResult, paidResult] = await Promise.allSettled([
+      client.request("GET", `/leads/${params.leadId}/contacts?IncludeEnriched=true`),
+      client.request("GET", `/leads/${params.leadId}/enrich/contacts?IncludeEnriched=true`)
+    ]);
+    const orgContacts = orgResult.status === "fulfilled" ? orgResult.value : [];
+    const paidContacts = paidResult.status === "fulfilled" ? paidResult.value : [];
+    return {
+      contacts: [
+        ...orgContacts.map((c) => ({
+          id: c.id,
+          first_name: c.first_name,
+          last_name: c.last_name,
+          email: c.email,
+          phone_number: c.phone_number,
+          linkedin_page: c.linkedin_page,
+          job_title: c.job_title,
+          recommended: c.recommended,
+          enrichment: c.enrichment,
+          source: "org"
+        })),
+        ...paidContacts.map((c) => ({
+          id: c.id,
+          first_name: c.first_name,
+          last_name: c.last_name,
+          email: c.email,
+          phone_number: c.phone_number,
+          linkedin_page: c.linkedin_page,
+          job_title: c.job_title,
+          recommended: c.recommended,
+          enrichment: c.enrichment,
+          source: "paid"
+        }))
+      ]
+    };
+  }
+};
+
+// ../core/dist/tools/get-quota.js
+var getQuota = {
+  name: "leadbay_get_quota",
+  description: "Read remaining quota / spend across daily, weekly, monthly windows for the org's resources (llm_completion, ai_rescore, web_fetch). Each entry shows current_units vs max_units and resets_at. When to use: after a 429 error, to explain to the user which window was hit and when it resets. When NOT to use: as a pre-flight gate before bulk operations \u2014 operations themselves return 429 with hints; this tool is for diagnostics, not gating.",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    const orgId = await client.resolveOrgId();
+    return await client.request("GET", `/organizations/${orgId}/quota_status`);
+  }
+};
+
+// ../core/dist/tools/get-taste-profile.js
+var getTasteProfile = {
+  name: "leadbay_get_taste_profile",
+  description: "Get the user's Ideal Buyer Profile, purchase intent tags, and qualification questions. When to use: at the very start of a session to understand what kind of leads the user is looking for. Data is cached. When NOT to use: per-lead \u2014 leadbay_research_lead already includes the per-lead qualification answers (which are scored against these org-level questions).",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  execute: async (client) => {
+    const profile = await client.resolveTasteProfile();
+    const isEmpty = !profile.idealBuyerProfile && profile.purchaseIntentTags.length === 0 && profile.qualificationQuestions.length === 0;
+    return {
+      ideal_buyer_profile: profile.idealBuyerProfile ? {
+        summary: profile.idealBuyerProfile.summary,
+        key_characteristics: profile.idealBuyerProfile.key_characteristics,
+        anti_patterns: profile.idealBuyerProfile.anti_patterns
+      } : null,
+      purchase_intent_tags: profile.purchaseIntentTags.map((t) => ({
+        display_name: t.display_name,
+        description: t.description,
+        score: t.score,
+        reasoning: t.reasoning
+      })),
+      qualification_questions: profile.qualificationQuestions.map((q) => ({
+        question: q.question
+      })),
+      ...isEmpty ? {
+        hint: "No taste profile configured yet. Set it up at app.leadbay.ai for better lead matching."
+      } : {}
+    };
+  }
+};
+
+// ../core/dist/tools/qualify-lead.js
+var qualifyLead = {
+  name: "leadbay_qualify_lead",
+  description: "Trigger AI qualification for a single lead (web fetch + AI rescore). The operation is asynchronous \u2014 results take ~60s. When to use: low-level. When NOT to use: as the agent's bulk-qualify path \u2014 use leadbay_bulk_qualify_leads, which paginates past already-qualified leads, fan-outs, polls, and bails out cleanly on 429.",
+  optional: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      },
+      forceFetch: {
+        type: "boolean",
+        description: "Force re-fetch even if recent data exists (default: false)"
+      }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    const force = params.forceFetch ?? false;
+    await client.requestVoid("POST", `/leads/${params.leadId}/web_fetch?force_fetch=${force}`);
+    return {
+      triggered: true,
+      hint: "AI qualification started. Use leadbay_get_lead_profile after ~60 seconds to check qualification results and web insights."
+    };
+  }
+};
+
+// ../core/dist/tools/enrich-contacts.js
+var enrichContacts = {
+  name: "leadbay_enrich_contacts",
+  description: "Order email and/or phone enrichment for a specific contact. When to use: when you have a specific contact_id (from leadbay_get_contacts) and want to enrich just that one. When NOT to use: for bulk enrichment by job title across many leads \u2014 use leadbay_enrich_titles, which handles the selection lifecycle and returns a clean preview/launch flow.",
+  optional: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      },
+      contactId: {
+        type: "string",
+        description: "Contact UUID (required)"
+      },
+      email: {
+        type: "boolean",
+        description: "Enrich email address (default: true)"
+      },
+      phone: {
+        type: "boolean",
+        description: "Enrich phone number (default: true)"
+      }
+    },
+    required: ["leadId", "contactId"]
+  },
+  execute: async (client, params) => {
+    const email = params.email ?? true;
+    const phone = params.phone ?? true;
+    if (!email && !phone) {
+      throw client.makeError("INVALID_PARAMS", "At least one of email or phone must be true", "Set email=true or phone=true");
+    }
+    let creditsRemaining = null;
+    try {
+      const me = await client.request("GET", "/users/me");
+      creditsRemaining = me.organization.billing?.ai_credits ?? null;
+      if (creditsRemaining !== null && creditsRemaining <= 0) {
+        throw client.makeError("QUOTA_EXCEEDED", "No enrichment credits remaining", "Purchase more credits at app.leadbay.ai");
+      }
+    } catch (e) {
+      if (e?.code === "QUOTA_EXCEEDED")
+        throw e;
+    }
+    const enrichPath = `/leads/${params.leadId}/enrich/contacts/${params.contactId}/enrich?email=${email}&phone=${phone}`;
+    try {
+      await client.requestVoid("POST", enrichPath);
+    } catch (e) {
+      if (e?.code === "NOT_FOUND") {
+        const orgPath = `/leads/${params.leadId}/contacts/${params.contactId}/enrich?email=${email}&phone=${phone}`;
+        await client.requestVoid("POST", orgPath);
+      } else {
+        throw e;
+      }
+    }
+    return {
+      triggered: true,
+      contact_id: params.contactId,
+      email_requested: email,
+      phone_requested: phone,
+      credits_remaining: creditsRemaining,
+      hint: "Enrichment started. Use leadbay_get_contacts after ~60 seconds to check results."
+    };
+  }
+};
+
+// ../core/dist/tools/add-note.js
+var addNote = {
+  name: "leadbay_add_note",
+  description: "Add a note to a lead. Notes are visible to the whole organization in Leadbay. When to use: low-level \u2014 for free-form notes not tied to outreach actions. When NOT to use: to log an outreach action \u2014 use leadbay_report_outreach, which requires verification (gmail/calendar/user_confirmed) to prevent hallucinated outreach poisoning the SDR pipeline.",
+  optional: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      },
+      note: {
+        type: "string",
+        description: "Note text (max 4095 characters)"
+      }
+    },
+    required: ["leadId", "note"]
+  },
+  execute: async (client, params) => {
+    if (!params.note || params.note.trim().length === 0) {
+      throw client.makeError("INVALID_PARAMS", "Note cannot be empty", "Provide a non-empty note");
+    }
+    const note = params.note.slice(0, 4095);
+    const result = await client.request("POST", `/leads/${params.leadId}/notes`, { note });
+    return {
+      id: result.id,
+      note: result.note,
+      created_at: result.created_at
+    };
+  }
+};
+
+// ../core/dist/tools/get-lead-activities.js
+var getLeadActivities = {
+  name: "leadbay_get_lead_activities",
+  description: "Get prospecting activity history for a lead (emails sent, calls made, status changes, notes). When to use: to avoid redundant outreach and understand where this lead is in the sales process. When NOT to use: when leadbay_research_lead has already been called \u2014 it includes recent prospecting actions in its engagement block.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      },
+      count: {
+        type: "number",
+        description: "Number of activities to return, max 100 (default: 50)"
+      }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    const count = Math.min(params.count ?? 50, 100);
+    const res = await client.request("GET", `/leads/${params.leadId}/activities?count=${count}`);
+    return {
+      activities: res.items.map((a) => ({
+        type: a.type,
+        date: a.date
+      })),
+      total: res.pagination.total
+    };
+  }
+};
+
+// ../core/dist/tools/get-lens-filter.js
+var getLensFilter = {
+  name: "leadbay_get_lens_filter",
+  description: "Read the firmographic filter (sectors, sizes, locations) currently applied to a lens. When to use: before adjusting an audience \u2014 see what's already restricted so changes are diffs, not full replacements. When NOT to use: to actually apply changes \u2014 use the leadbay_adjust_audience composite, which handles permissions transparently.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      lensId: { type: "number", description: "Lens id (required)" }
+    },
+    required: ["lensId"]
+  },
+  execute: async (client, params) => {
+    return await client.request("GET", `/lenses/${params.lensId}/filter`);
+  }
+};
+
+// ../core/dist/tools/get-lens-scoring.js
+var getLensScoring = {
+  name: "leadbay_get_lens_scoring",
+  description: "Read the AI-scoring criteria configured on a lens (what makes a lead score 100 vs 30). When to use: when explaining why a lead got the score it did. When NOT to use: to mutate scoring \u2014 that's an admin/setup operation, not part of the agent loop.",
+  inputSchema: {
+    type: "object",
+    properties: { lensId: { type: "number", description: "Lens id (required)" } },
+    required: ["lensId"]
+  },
+  execute: async (client, params) => {
+    return await client.request("GET", `/lenses/${params.lensId}/scoring`);
+  }
+};
+
+// ../core/dist/tools/list-sectors.js
+var listSectors = {
+  name: "leadbay_list_sectors",
+  description: "List the sector taxonomy (id + display name in the requested language). When to use: to resolve a free-text sector name (e.g. 'Healthcare') into the sector ids that leadbay_adjust_audience needs. Default: lang follows the caller's language; includeInvisible=false returns ~1,091 visible sectors. When NOT to use: when you already have sector ids \u2014 pass them directly.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      lang: { type: "string", description: "BCP-47 language tag (default: en)" },
+      includeInvisible: {
+        type: "boolean",
+        description: "Include sectors hidden from the UI (default false; ~91k items if true)"
+      }
+    }
+  },
+  execute: async (client, params) => {
+    let lang = params.lang;
+    if (!lang) {
+      try {
+        const me = await client.resolveMe();
+        lang = me.language ?? "en";
+      } catch {
+        lang = "en";
+      }
+    }
+    const includeInvisible = params.includeInvisible ? "true" : "false";
+    const path = `/sectors/all?lang=${encodeURIComponent(lang)}&includeInvisible=${includeInvisible}`;
+    return await client.request("GET", path);
+  }
+};
+
+// ../core/dist/tools/get-user-prompt.js
+var getUserPrompt = {
+  name: "leadbay_get_user_prompt",
+  description: "Read the org's intelligence-refinement prompt (free-text instruction that steers lead recommendations beyond firmographics). Returns null if none is set (the backend returns 204 in that case). When to use: to know what's currently steering the agent's recommendations before suggesting a refine. When NOT to use: to set/change the prompt \u2014 use leadbay_refine_prompt.",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    const orgId = await client.resolveOrgId();
+    const prompt = await client.request("GET", `/organizations/${orgId}/user_prompt`);
+    return prompt ?? { prompt: null, set: false };
+  }
+};
+
+// ../core/dist/tools/get-clarification.js
+var getClarification = {
+  name: "leadbay_get_clarification",
+  description: "Check whether Leadbay has a pending clarification question \u2014 a question raised when refining the intelligence prompt produced contradictory or ambiguous criteria. Returns null when nothing is pending (the backend returns 204). When to use: after leadbay_refine_prompt, to see if Leadbay needs the user to disambiguate. When NOT to use: to answer the question \u2014 use leadbay_answer_clarification.",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    const orgId = await client.resolveOrgId();
+    const c = await client.request("GET", `/organizations/${orgId}/clarifications`);
+    return c ?? { pending: false, clarification: null };
+  }
+};
+
+// ../core/dist/tools/get-lead-notes.js
+var getLeadNotes = {
+  name: "leadbay_get_lead_notes",
+  description: "Read existing notes on a lead \u2014 context the human team or prior agent runs have already captured. When to use: before adding a note via leadbay_report_outreach, to avoid duplicating or overwriting context the SDR already wrote. When NOT to use: when the lead summary's notes_count is 0 \u2014 there's nothing to fetch.",
+  inputSchema: {
+    type: "object",
+    properties: { leadId: { type: "string", description: "Lead UUID (required)" } },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    return await client.request("GET", `/leads/${params.leadId}/notes`);
+  }
+};
+
+// ../core/dist/tools/get-epilogue-responses.js
+var getEpilogueResponses = {
+  name: "leadbay_get_epilogue_responses",
+  description: "Read the lead's epilogue history \u2014 what status (still chasing, meeting booked, etc.) was set when, and by whom. When to use: to see the lead's outreach progression before deciding the next step. When NOT to use: when the lead summary's epilogue_actions_count is 0.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: { type: "string", description: "Lead UUID (required)" },
+      count: { type: "number", description: "Items per page (1-200, default 20)" },
+      page: { type: "number", description: "Page number, 0-indexed (default 0)" }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    const count = params.count ?? 20;
+    const page = params.page ?? 0;
+    return await client.request("GET", `/leads/${params.leadId}/epilogue_responses?count=${count}&page=${page}`);
+  }
+};
+
+// ../core/dist/tools/get-prospecting-actions.js
+var getProspectingActions = {
+  name: "leadbay_get_prospecting_actions",
+  description: "Read the CRM-style activity log for a lead (calls, emails, meetings \u2014 actions performed by humans or prior agent runs). When to use: before contacting the lead, to avoid duplicating outreach the team already did. When NOT to use: when the lead summary's prospecting_actions_count is 0.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: { type: "string", description: "Lead UUID (required)" },
+      count: { type: "number", description: "Items per page (1-200, default 20)" },
+      page: { type: "number", description: "Page number, 0-indexed (default 0)" }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    const count = params.count ?? 20;
+    const page = params.page ?? 0;
+    return await client.request("GET", `/leads/${params.leadId}/prospecting_actions?count=${count}&page=${page}`);
+  }
+};
+
+// ../core/dist/tools/get-web-fetch.js
+var getWebFetch = {
+  name: "leadbay_get_web_fetch",
+  description: "Read the AI-generated web-research summary for a lead \u2014 company profile, business signals, prospecting clues, each with sources and 'hot' flags marking high-signal recent items. The content is dictioned by emoji-prefixed section labels in the raw API. When to use: when the agent already qualified this lead and wants the underlying research to reason from. When NOT to use: as the first read on a lead \u2014 the leadbay_research_lead composite bundles this with qualification answers and reshapes the dict into a stable array form.",
+  inputSchema: {
+    type: "object",
+    properties: { leadId: { type: "string", description: "Lead UUID (required)" } },
+    required: ["leadId"]
+  },
+  execute: async (client, params) => {
+    return await client.request("GET", `/leads/${params.leadId}/web_fetch`);
+  }
+};
+
+// ../core/dist/tools/get-selection-ids.js
+var getSelectionIds = {
+  name: "leadbay_get_selection_ids",
+  description: "List the lead ids currently in the user's selection (the transient set that bulk operations like enrichment act on). When to use: to verify the selection state before/after bulk ops if a composite call has misbehaved. When NOT to use: in the normal flow \u2014 leadbay_enrich_titles manages selection lifecycle automatically (select \u2192 action \u2192 clear).",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    return await client.request("GET", "/leads/selection/ids");
+  }
+};
+
+// ../core/dist/tools/get-enrichment-job-titles.js
+var getEnrichmentJobTitles = {
+  name: "leadbay_get_enrichment_job_titles",
+  description: "List the actual job titles present across the leads currently in the user's selection \u2014 the candidate set the user can ask to enrich. When to use: after leadbay_select_leads, to know which titles are even available before launching a bulk enrichment. When NOT to use: standalone \u2014 the selection must already be populated, otherwise the result is an empty array. leadbay_enrich_titles wraps this whole flow when you don't need to inspect the title list manually.",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    return await client.request("GET", "/leads/selection/enrichment/job_titles");
+  }
+};
+
+// ../core/dist/tools/select-leads.js
+var selectLeads = {
+  name: "leadbay_select_leads",
+  description: "Add leads to the user's transient selection (used by selection-scoped bulk operations). When to use: low-level. The user's selection is a per-token global state \u2014 be careful when invoking directly. When NOT to use: in normal flow \u2014 leadbay_enrich_titles wraps select \u2192 action \u2192 clear in one call with proper Mutex protection. Calling this directly without acquiring the selection lock can clobber concurrent composite calls.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs to add to selection (1-1000)",
+        minItems: 1,
+        maxItems: 1e3
+      }
+    },
+    required: ["leadIds"]
+  },
+  execute: async (client, params) => {
+    const qs = params.leadIds.map((id) => `leadIds=${encodeURIComponent(id)}`).join("&");
+    await client.requestVoid("POST", `/leads/selection/select?${qs}`);
+    return { selected: params.leadIds.length };
+  }
+};
+
+// ../core/dist/tools/deselect-leads.js
+var deselectLeads = {
+  name: "leadbay_deselect_leads",
+  description: "Remove leads from the user's transient selection. When to use: when narrowing a previously-built selection without clearing it entirely. When NOT to use: in normal flow \u2014 leadbay_enrich_titles handles selection lifecycle.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs to remove from selection",
+        minItems: 1
+      }
+    },
+    required: ["leadIds"]
+  },
+  execute: async (client, params) => {
+    const qs = params.leadIds.map((id) => `leadIds=${encodeURIComponent(id)}`).join("&");
+    await client.requestVoid("POST", `/leads/selection/deselect?${qs}`);
+    return { deselected: params.leadIds.length };
+  }
+};
+
+// ../core/dist/tools/clear-selection.js
+var clearSelection = {
+  name: "leadbay_clear_selection",
+  description: "Clear the user's transient selection. When to use: cleanup after manual selection work, or recovery from a stuck composite. When NOT to use: in normal flow \u2014 composites clear in their own finally blocks.",
+  optional: true,
+  write: true,
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    await client.requestVoid("POST", "/leads/selection/clear");
+    return { cleared: true };
+  }
+};
+
+// ../core/dist/tools/set-active-lens.js
+var setActiveLens = {
+  name: "leadbay_set_active_lens",
+  description: "Mark a lens as last-used. Subsequent /me reads return it as last_requested_lens, so all composite tools default to it. When to use: after the user explicitly switched contexts (e.g. created a new lens via leadbay_create_lens). When NOT to use: in normal flow \u2014 leadbay_pull_leads and leadbay_adjust_audience auto-set the right lens.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: { lensId: { type: "number", description: "Lens id (required)" } },
+    required: ["lensId"]
+  },
+  execute: async (client, params) => {
+    await client.requestVoid("POST", `/lenses/${params.lensId}/update_last_requested`);
+    client.invalidateMe();
+    client.invalidateDefaultLens();
+    return { active_lens_id: params.lensId };
+  }
+};
+
+// ../core/dist/tools/create-lens.js
+var createLens = {
+  name: "leadbay_create_lens",
+  description: "Create a new user-level lens by cloning an existing lens's filter/scoring as the starting point. When to use: when adjust_audience determined the current lens cannot be edited (e.g. it's the org default). When NOT to use: to update an existing lens \u2014 use leadbay_update_lens or leadbay_update_lens_filter.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      base: { type: "number", description: "Base lens id to clone from" },
+      name: { type: "string", description: "Display name for the new lens" },
+      description: { type: "string" }
+    },
+    required: ["base", "name"]
+  },
+  execute: async (client, params) => {
+    const lens = await client.request("POST", "/lenses", {
+      base: params.base,
+      name: params.name,
+      description: params.description
+    });
+    client.invalidateDefaultLens();
+    return lens;
+  }
+};
+
+// ../core/dist/tools/update-lens.js
+var updateLens = {
+  name: "leadbay_update_lens",
+  description: "Update lens metadata (name, description, mode flags). Does NOT change the audience filter \u2014 use leadbay_update_lens_filter for that. When to use: rename a lens or toggle multi_product_mode/use_hq_only. When NOT to use: to change which leads the lens shows \u2014 that's a filter operation.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      lensId: { type: "number" },
+      name: { type: "string" },
+      description: { type: "string" },
+      multi_product_mode: { type: "boolean" },
+      use_hq_only: { type: "boolean" }
+    },
+    required: ["lensId"]
+  },
+  execute: async (client, params) => {
+    const { lensId, ...body } = params;
+    await client.requestVoid("POST", `/lenses/${lensId}`, body);
+    client.invalidateDefaultLens();
+    return { updated: true, lens_id: lensId };
+  }
+};
+
+// ../core/dist/tools/update-lens-filter.js
+var updateLensFilter = {
+  name: "leadbay_update_lens_filter",
+  description: "Replace the audience filter (sectors, sizes, locations) on a lens. Body is the full Filter object \u2014 this is a REPLACE, not a merge. Returns 400 'default_lens' if applied to the org default lens (clone it first). When to use: low-level mutation when you've already prepared the merged filter. When NOT to use: from agent flow \u2014 use leadbay_adjust_audience, which handles draft-vs-direct routing, permission fallback, and the merge logic so unrelated criteria aren't dropped.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      lensId: { type: "number", description: "Lens id" },
+      filter: {
+        type: "object",
+        description: "Full FilterPayload (lens_filter + locations)"
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, return the call shape that WOULD be sent without contacting the backend"
+      }
+    },
+    required: ["lensId", "filter"]
+  },
+  execute: async (client, params) => {
+    if (params.dry_run) {
+      return {
+        dry_run: true,
+        would_call: {
+          method: "POST",
+          path: `/lenses/${params.lensId}/filter`,
+          body: params.filter
+        }
+      };
+    }
+    await client.requestVoid("POST", `/lenses/${params.lensId}/filter`, params.filter);
+    client.invalidateDefaultLens();
+    return { updated: true, lens_id: params.lensId };
+  }
+};
+
+// ../core/dist/tools/create-lens-draft.js
+var createLensDraft = {
+  name: "leadbay_create_lens_draft",
+  description: "Create (or fetch existing) draft of an org-level lens. Idempotent \u2014 same user calling twice returns the same draft. The returned lens has draft_of set to the original lens id. When to use: when a non-admin needs to modify an org-level lens \u2014 make a draft, edit the draft. When NOT to use: from agent flow \u2014 leadbay_adjust_audience handles the draft-routing transparently.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: { lensId: { type: "number", description: "Lens id of the org-level lens to draft" } },
+    required: ["lensId"]
+  },
+  execute: async (client, params) => {
+    return await client.request("POST", `/lenses/${params.lensId}/draft`);
+  }
+};
+
+// ../core/dist/tools/promote-lens.js
+var promoteLens = {
+  name: "leadbay_promote_lens",
+  description: "Promote a user-level lens (or draft) to org-level so all teammates see it. Admin-only. When to use: rare \u2014 when an admin user has built a lens (or refined a draft) and wants to share it org-wide. When NOT to use: as a non-admin (will fail with 403); for personal lens changes (those stay user-scoped).",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: { lensId: { type: "number" } },
+    required: ["lensId"]
+  },
+  execute: async (client, params) => {
+    await client.requestVoid("POST", `/lenses/${params.lensId}/promote`);
+    client.invalidateDefaultLens();
+    return { promoted: true, lens_id: params.lensId };
+  }
+};
+
+// ../core/dist/tools/set-user-prompt.js
+var setUserPrompt = {
+  name: "leadbay_set_user_prompt",
+  description: "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). When to use: low-level. When NOT to use: from agent flow \u2014 use leadbay_refine_prompt, which polls for follow-up clarifications.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      prompt: { type: "string", description: "Refinement instruction (free text)" },
+      dry_run: {
+        type: "boolean",
+        description: "If true, return the call shape that WOULD be sent without contacting the backend"
+      }
+    },
+    required: ["prompt"]
+  },
+  execute: async (client, params) => {
+    const orgId = await client.resolveOrgId();
+    if (params.dry_run) {
+      return {
+        dry_run: true,
+        would_call: {
+          method: "POST",
+          path: `/organizations/${orgId}/user_prompt`,
+          body: { prompt: params.prompt }
+        }
+      };
+    }
+    await client.requestVoid("POST", `/organizations/${orgId}/user_prompt`, {
+      prompt: params.prompt
+    });
+    client.invalidateMe();
+    return { set: true };
+  }
+};
+
+// ../core/dist/tools/clear-user-prompt.js
+var clearUserPrompt = {
+  name: "leadbay_clear_user_prompt",
+  description: "Remove the org's intelligence-refinement prompt (revert to AI-only generation). Admin-only. Triggers full intelligence regeneration. When to use: when a refinement turned out to be the wrong direction. When NOT to use: to replace with a different prompt \u2014 just call leadbay_refine_prompt; that overwrites.",
+  optional: true,
+  write: true,
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    const orgId = await client.resolveOrgId();
+    await client.requestVoid("DELETE", `/organizations/${orgId}/user_prompt`);
+    client.invalidateMe();
+    return { cleared: true };
+  }
+};
+
+// ../core/dist/tools/pick-clarification.js
+var pickClarification = {
+  name: "leadbay_pick_clarification",
+  description: "Answer the pending clarification question \u2014 either by picking one of the offered options (option_id) or by typing a free-text answer. The answer is stored as the new user_prompt and triggers regeneration. Admin-only. When to use: low-level. When NOT to use: from agent flow \u2014 use leadbay_answer_clarification.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      option_id: { type: "string", description: "Id of one of the clarification's options" },
+      text_answer: { type: "string", description: "Free-text answer (overrides option_id if both are set)" }
+    }
+  },
+  execute: async (client, params) => {
+    if (!params.option_id && !params.text_answer) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: "Provide either option_id or text_answer",
+        hint: "Call leadbay_get_clarification to see the options first"
+      };
+    }
+    const orgId = await client.resolveOrgId();
+    await client.requestVoid("POST", `/organizations/${orgId}/pick_clarification`, params);
+    client.invalidateMe();
+    return { answered: true };
+  }
+};
+
+// ../core/dist/tools/dismiss-clarification.js
+var dismissClarification = {
+  name: "leadbay_dismiss_clarification",
+  description: "Dismiss the pending clarification without answering. Leadbay proceeds with its best guess. Admin-only. When to use: when the user explicitly doesn't want to answer the disambiguation. When NOT to use: as a default \u2014 answering with even a free-text reason gives Leadbay better signal.",
+  optional: true,
+  write: true,
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client) => {
+    const orgId = await client.resolveOrgId();
+    await client.requestVoid("POST", `/organizations/${orgId}/dismiss_clarification`);
+    client.invalidateMe();
+    return { dismissed: true };
+  }
+};
+
+// ../core/dist/tools/set-epilogue-status.js
+var EPILOGUE_LABEL_MAP = {
+  STILL_CHASING: "EPILOGUE_STILL_CHASING",
+  COULD_NOT_REACH_STILL_TRYING: "EPILOGUE_COULD_NOT_REACH_STILL_TRYING",
+  INTEREST_VALIDATED_OR_MEETING_PLANED: "EPILOGUE_INTEREST_VALIDATED_OR_MEETING_PLANED",
+  NOT_INTERESTED_LOST: "EPILOGUE_NOT_INTERESTED_LOST",
+  // Also accept the long forms verbatim
+  EPILOGUE_STILL_CHASING: "EPILOGUE_STILL_CHASING",
+  EPILOGUE_COULD_NOT_REACH_STILL_TRYING: "EPILOGUE_COULD_NOT_REACH_STILL_TRYING",
+  EPILOGUE_INTEREST_VALIDATED_OR_MEETING_PLANED: "EPILOGUE_INTEREST_VALIDATED_OR_MEETING_PLANED",
+  EPILOGUE_NOT_INTERESTED_LOST: "EPILOGUE_NOT_INTERESTED_LOST"
+};
+var setEpilogueStatus = {
+  name: "leadbay_set_epilogue_status",
+  description: "Bulk-set the outreach progress (epilogue) status across a set of leads. Status values: STILL_CHASING, COULD_NOT_REACH_STILL_TRYING, INTEREST_VALIDATED_OR_MEETING_PLANED ('meeting booked'), NOT_INTERESTED_LOST (short labels accepted; mapped to the EPILOGUE_* enum). Up to 1000 leads per call. When to use: low-level. When NOT to use: from agent flow \u2014 leadbay_report_outreach pairs this with a note + verification, which is what humans actually need to see in Leadbay.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      lead_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs (1-1000)"
+      },
+      status: {
+        type: "string",
+        description: "One of: STILL_CHASING, COULD_NOT_REACH_STILL_TRYING, INTEREST_VALIDATED_OR_MEETING_PLANED, NOT_INTERESTED_LOST"
+      }
+    },
+    required: ["lead_ids", "status"]
+  },
+  execute: async (client, params) => {
+    const wire = EPILOGUE_LABEL_MAP[params.status];
+    if (!wire) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: `Unknown epilogue status: ${params.status}`,
+        hint: `Use one of: ${Object.keys(EPILOGUE_LABEL_MAP).filter((k) => !k.startsWith("EPILOGUE_")).join(", ")}`
+      };
+    }
+    await client.requestVoid("POST", "/leads/epilogue", {
+      lead_ids: params.lead_ids,
+      status: wire
+    });
+    return { applied: true, count: params.lead_ids.length, status: wire };
+  }
+};
+
+// ../core/dist/tools/remove-epilogue.js
+var removeEpilogue = {
+  name: "leadbay_remove_epilogue",
+  description: "Bulk-clear the epilogue status from a set of leads. When to use: when an outreach action was logged in error and needs to be undone. When NOT to use: to change status \u2014 call leadbay_set_epilogue_status with the new status (it overwrites).",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      lead_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs"
+      }
+    },
+    required: ["lead_ids"]
+  },
+  execute: async (client, params) => {
+    await client.requestVoid("POST", "/leads/remove_epilogue", {
+      lead_ids: params.lead_ids
+    });
+    return { cleared: true, count: params.lead_ids.length };
+  }
+};
+
+// ../core/dist/tools/preview-bulk-enrichment.js
+var previewBulkEnrichment = {
+  name: "leadbay_preview_bulk_enrichment",
+  description: "Preview a bulk-enrichment cost given a set of job titles applied to the current selection. Returns {selected_leads, enriched_contacts, enrichable_contacts, title_suggestions, auto_included_titles, previously_enriched_titles}. previously_enriched_titles is a newer field (in prod soon) \u2014 when present, the agent can recommend repeating those titles for new leads. When to use: between selecting leads and launching, to know what the enrichment will cost. When NOT to use: from agent flow \u2014 leadbay_enrich_titles wraps preview + launch with the right safety checks.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      titles: {
+        type: "array",
+        items: { type: "string" },
+        description: "Job titles to enrich (matched against contacts in selected leads)"
+      }
+    },
+    required: ["titles"]
+  },
+  execute: async (client, params) => {
+    return await client.request("POST", "/leads/selection/enrichment/preview", { titles: params.titles });
+  }
+};
+
+// ../core/dist/tools/launch-bulk-enrichment.js
+var launchBulkEnrichment = {
+  name: "leadbay_launch_bulk_enrichment",
+  description: "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; contact.enrichment.done flips to true. When to use: low-level. When NOT to use: from agent flow \u2014 leadbay_enrich_titles handles selection lifecycle, preview, launch, and cleanup.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      titles: { type: "array", items: { type: "string" } },
+      email: { type: "boolean", description: "Enrich emails (default true)" },
+      phone: { type: "boolean", description: "Enrich phone numbers (default false)" },
+      dry_run: {
+        type: "boolean",
+        description: "If true, return the call shape WITHOUT contacting the backend"
+      }
+    },
+    required: ["titles"]
+  },
+  execute: async (client, params) => {
+    const email = params.email ?? true;
+    const phone = params.phone ?? false;
+    if (!email && !phone) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: "Either email or phone must be true",
+        hint: "Set email:true to enrich emails (most common), or phone:true for phone numbers"
+      };
+    }
+    if (params.dry_run) {
+      return {
+        dry_run: true,
+        would_call: {
+          method: "POST",
+          path: "/leads/selection/enrichment/launch",
+          body: { titles: params.titles, email, phone }
+        }
+      };
+    }
+    await client.requestVoid("POST", "/leads/selection/enrichment/launch", {
+      titles: params.titles,
+      email,
+      phone
+    });
+    return {
+      launched: true,
+      titles: params.titles,
+      email,
+      phone,
+      hint: "Enrichment job launched. Poll individual leads' contacts after ~60s via leadbay_get_contacts(leadId) \u2014 contact.enrichment.done flips to true when done."
+    };
+  }
+};
+
+// ../core/dist/composite/research-company.js
+var researchCompany = {
+  name: "leadbay_research_company",
+  description: "Deep-dive research on a specific company by NAME (fuzzy match against the active lens's wishlist). When to use: when the user references a company by name and you don't yet have its lead_id. When NOT to use: when you already have the lead_id \u2014 use leadbay_research_lead directly (it bundles richer signals + better top-down ordering for the agent).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      companyName: {
+        type: "string",
+        description: "Company name to research (one of companyName or leadId required). Matches the top-scoring lead with this name."
+      },
+      leadId: {
+        type: "string",
+        description: "Lead UUID if already known (one of companyName or leadId required). Takes precedence over companyName."
+      }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    if (!params.leadId && !params.companyName) {
+      throw client.makeError("INVALID_PARAMS", "Pass either leadId or companyName", "Call leadbay_pull_leads first to surface candidate leads with their IDs, then call this with leadId.");
+    }
+    let leadId = params.leadId;
+    if (!leadId && params.companyName) {
+      const results = await discoverLeads.execute(client, { count: 50, page: 0 }, ctx);
+      const needle = params.companyName.toLowerCase();
+      const match = results.leads.find((l) => l.name.toLowerCase().includes(needle));
+      if (!match) {
+        throw client.makeError("LEAD_NOT_FOUND", `No lead matching "${params.companyName}" in the current lens`, "Call leadbay_pull_leads (optionally with a broader lensId) to see what's available, then call this with leadId.");
+      }
+      leadId = match.id;
+    }
+    const [profile, activities] = await Promise.allSettled([
+      getLeadProfile.execute(client, { leadId }, ctx),
+      getLeadActivities.execute(client, { leadId, count: 20 }, ctx)
+    ]);
+    if (profile.status === "rejected") {
+      throw profile.reason;
+    }
+    return {
+      ...profile.value,
+      recent_activities: activities.status === "fulfilled" ? activities.value.activities : []
+    };
+  }
+};
+
+// ../core/dist/composite/prepare-outreach.js
+var prepareOutreach = {
+  name: "leadbay_prepare_outreach",
+  description: "Prepare an outreach package for a single lead: recommended contact + enriched contact details + AI summary. When to use: when the agent is about to draft outreach for ONE specific lead and needs the contact's email/phone. When NOT to use: across many leads \u2014 use leadbay_enrich_titles for bulk; for general lead detail use leadbay_research_lead (richer signals); to actually log the outreach action use leadbay_report_outreach (requires verification).",
+  optional: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: {
+        type: "string",
+        description: "Lead UUID (required)"
+      },
+      enrich: {
+        type: "boolean",
+        description: "If true and credits available, trigger enrichment on the recommended contact (default: false). Enrichment is async \u2014 poll leadbay_get_contacts after ~60s."
+      }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params, ctx) => {
+    const contactsResult = await getContacts.execute(client, { leadId: params.leadId }, ctx);
+    const contacts = contactsResult.contacts;
+    const recommended = contacts.find((c) => c.recommended) ?? contacts[0];
+    let enrichmentTriggered = false;
+    let enrichmentError = null;
+    if (params.enrich && recommended) {
+      try {
+        await enrichContacts.execute(client, { leadId: params.leadId, contactId: recommended.id }, ctx);
+        enrichmentTriggered = true;
+      } catch (e) {
+        enrichmentError = e?.message ?? String(e);
+      }
+    }
+    let leadSummary = null;
+    try {
+      const profile = await getLeadProfile.execute(client, { leadId: params.leadId }, ctx);
+      leadSummary = {
+        name: profile.lead.name,
+        ai_summary: profile.lead.ai_summary,
+        website: profile.lead.website
+      };
+    } catch {
+    }
+    return {
+      lead: leadSummary,
+      recommended_contact: recommended ? {
+        id: recommended.id,
+        name: [recommended.first_name, recommended.last_name].filter(Boolean).join(" "),
+        job_title: recommended.job_title,
+        email: recommended.email,
+        phone_number: recommended.phone_number,
+        linkedin_page: recommended.linkedin_page
+      } : null,
+      other_contacts_count: Math.max(0, contacts.length - 1),
+      enrichment: {
+        triggered: enrichmentTriggered,
+        error: enrichmentError,
+        hint: enrichmentTriggered ? "Enrichment started. Poll leadbay_get_contacts with the same leadId in ~60 seconds." : null
+      }
+    };
+  }
+};
+
+// ../core/dist/composite/pull-leads.js
+function summarise(responses) {
+  const answered = responses.filter((r) => r.score != null).length;
+  const total = responses.length;
+  const scores = responses.map((r) => r.score).filter((s) => s != null);
+  const avg = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10 : null;
+  const best = [...responses].filter((r) => r.response && r.score != null).sort((a, b) => (b.score ?? 0) - (a.score ?? 0))[0];
+  let excerpt = best?.response ?? null;
+  if (excerpt && excerpt.length > 200) {
+    excerpt = excerpt.slice(0, 197) + "...";
+  }
+  return { answered, total, avg_score_0_to_10: avg, best_response_excerpt: excerpt };
+}
+var pullLeads = {
+  name: "leadbay_pull_leads",
+  description: "Pull up new leads from the user's last-active lens (the canonical 'show me prospects to work on' tool). Each returned lead carries a one-line qualification_summary built from leadbay_ai_agent_responses, plus the rich tags / scores / recommended_contact_title / engagement counters / in-flight flags from the lead summary. When to use: as the agent's default opening move when the user wants to see leads. When NOT to use: when the user has named a specific lens \u2014 pass lensId to override the auto-resolution. Replaces the older leadbay_find_prospects (which is removed in v0.2.0).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      lensId: {
+        type: "number",
+        description: "Override the auto-resolved last-active lens (escape hatch \u2014 normally omit)"
+      },
+      count: { type: "number", description: "Leads per page, max 50 (default 20)" },
+      page: { type: "number", description: "Page number, 0-indexed (default 0)" },
+      verbose: {
+        type: "boolean",
+        description: "If true, include the full set of lead-summary fields. Default false: returns the trimmed agent-friendly form."
+      }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    const lensId = params.lensId ?? await client.resolveDefaultLens();
+    const page = params.page ?? 0;
+    const count = Math.min(params.count ?? 20, 50);
+    const verbose = params.verbose ?? false;
+    const res = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=${count}&page=${page}&contacts=true`);
+    const summaries = await Promise.all(res.items.map(async (lead) => {
+      try {
+        const r = await client.request("GET", `/leads/${lead.id}/ai_agent_responses`);
+        return { leadId: lead.id, summary: summarise(r) };
+      } catch (err) {
+        ctx?.logger?.warn?.(`pull_leads: ai_agent_responses failed for lead ${lead.id}: ${err?.message ?? err?.code ?? err}`);
+        return {
+          leadId: lead.id,
+          summary: {
+            answered: 0,
+            total: 0,
+            avg_score_0_to_10: null,
+            best_response_excerpt: null
+          }
+        };
+      }
+    }));
+    const summaryMap = new Map(summaries.map((s) => [s.leadId, s.summary]));
+    const trimmed = (lead) => verbose ? lead : {
+      id: lead.id,
+      name: lead.name,
+      score: lead.score,
+      ai_agent_lead_score: lead.ai_agent_lead_score,
+      location: lead.location,
+      short_description: lead.short_description ?? lead.description,
+      size: lead.size,
+      website: lead.website,
+      tags: lead.tags,
+      recommended_contact_title: lead.recommended_contact_title ?? null,
+      recommended_contact: lead.recommended_contact ?? null,
+      web_fetch_in_progress: lead.web_fetch_in_progress ?? false,
+      enrichment_in_progress: lead.enrichment_in_progress ?? false,
+      liked: lead.liked,
+      disliked: lead.disliked,
+      new: lead.new ?? false,
+      contacts_count: lead.contacts_count,
+      org_contacts_count: lead.org_contacts_count,
+      notes_count: lead.notes_count ?? 0,
+      epilogue_actions_count: lead.epilogue_actions_count ?? 0,
+      prospecting_actions_count: lead.prospecting_actions_count ?? 0
+    };
+    return {
+      lens: { id: lensId },
+      leads: res.items.map((lead) => ({
+        ...trimmed(lead),
+        qualification_summary: summaryMap.get(lead.id) ?? null
+      })),
+      pagination: res.pagination,
+      computing_wishlist: res.computing_wishlist,
+      computing_scores: res.computing_scores,
+      _meta: {
+        region: client.region,
+        latency_ms: client.lastMeta?.latency_ms ?? null
+      }
+    };
+  }
+};
+
+// ../core/dist/composite/research-lead.js
+var SECTION_PRIORITY = ["profile", "signals", "clues"];
+function splitEmojiSection(key) {
+  const m = key.match(/^([^\p{L}\p{N}\s]+)\s+(.+)$/u);
+  if (m)
+    return { emoji: m[1], label: m[2] };
+  return { emoji: null, label: key };
+}
+function reshapeWebFetchContent(content) {
+  if (!content)
+    return [];
+  const sections = [];
+  for (const [key, val] of Object.entries(content)) {
+    if (!Array.isArray(val))
+      continue;
+    const { emoji, label } = splitEmojiSection(key);
+    sections.push({
+      section_label: label,
+      section_emoji: emoji,
+      entries: val
+    });
+  }
+  sections.sort((a, b) => {
+    const ai = SECTION_PRIORITY.findIndex((p) => a.section_label.toLowerCase().includes(p));
+    const bi = SECTION_PRIORITY.findIndex((p) => b.section_label.toLowerCase().includes(p));
+    const aN = ai < 0 ? SECTION_PRIORITY.length : ai;
+    const bN = bi < 0 ? SECTION_PRIORITY.length : bi;
+    if (aN !== bN)
+      return aN - bN;
+    return a.section_label.localeCompare(b.section_label);
+  });
+  return sections;
+}
+var researchLead = {
+  name: "leadbay_research_lead",
+  description: "Tell me everything decision-relevant about a single lead. Bundles the lens-scoped lead profile, the AI qualification answers (the agent's knowledge-base food), the structured web-research signals (with hot flags + sources), the enriched contacts, and the recent notes/epilogue/prospecting activity in one call. Order is deliberate: qualification first, then signals, then firmographics, then contacts, then engagement. When to use: when picking up a single lead from leadbay_pull_leads to decide whether to act on it. When NOT to use: across many leads at once \u2014 that's leadbay_pull_leads' job. (This composite supersedes the lower-level leadbay_get_lead_profile in agent flow; the granular tool stays available for fine-grained access.)",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadId: { type: "string", description: "Lead UUID (required)" },
+      lensId: {
+        type: "number",
+        description: "Lens id (escape hatch \u2014 normally omit; auto-resolves to the active lens)"
+      },
+      concise: {
+        type: "boolean",
+        description: "If true, trim signals to hot=true items only (smaller payload). Default false."
+      }
+    },
+    required: ["leadId"]
+  },
+  execute: async (client, params, ctx) => {
+    const lensId = params.lensId ?? await client.resolveDefaultLens();
+    const leadId = params.leadId;
+    const [profileR, qualR, contactsR, webFetchR] = await Promise.allSettled([
+      client.request("GET", `/lenses/${lensId}/leads/${leadId}`),
+      client.request("GET", `/leads/${leadId}/ai_agent_responses`),
+      client.request("GET", `/leads/${leadId}/enrich/contacts?IncludeEnriched=true`),
+      client.request("GET", `/leads/${leadId}/web_fetch`)
+    ]);
+    if (profileR.status === "rejected") {
+      throw profileR.reason;
+    }
+    const lead = profileR.value;
+    const wantNotes = (lead.notes_count ?? 0) > 0;
+    const wantEpilogue = (lead.epilogue_actions_count ?? 0) > 0;
+    const wantProspecting = (lead.prospecting_actions_count ?? 0) > 0;
+    const wantOrgContacts = (lead.org_contacts_count ?? 0) > 0;
+    const engagementFetches = await Promise.allSettled([
+      wantNotes ? client.request("GET", `/leads/${leadId}/notes`) : Promise.resolve(null),
+      wantEpilogue ? client.request("GET", `/leads/${leadId}/epilogue_responses?count=10&page=0`) : Promise.resolve(null),
+      wantProspecting ? client.request("GET", `/leads/${leadId}/prospecting_actions?count=10&page=0`) : Promise.resolve(null),
+      wantOrgContacts ? client.request("GET", `/leads/${leadId}/contacts?IncludeEnriched=true`) : Promise.resolve(null)
+    ]);
+    const [notesR, epilogueR, prospR, orgContactsR] = engagementFetches;
+    const valOrNull = (r) => r.status === "fulfilled" ? r.value ?? null : null;
+    let signals = reshapeWebFetchContent(webFetchR.status === "fulfilled" ? webFetchR.value?.content ?? null : null);
+    if (params.concise) {
+      signals = signals.map((s) => ({
+        ...s,
+        entries: s.entries.filter((e) => e.hot === true)
+      })).filter((s) => s.entries.length > 0);
+    }
+    const paidContacts = contactsR.status === "fulfilled" ? contactsR.value : [];
+    const orgContacts = valOrNull(orgContactsR) ?? [];
+    return {
+      // 1) qualification — single most important block for "is this lead worth pursuing"
+      qualification: qualR.status === "fulfilled" ? qualR.value.map((r) => ({
+        question: r.question,
+        score_0_to_10: r.score,
+        response: r.response,
+        computed_at: r.computed_at
+      })) : [],
+      // 2) signals — knowledge-base food
+      signals,
+      // 3) firmographics
+      firmographics: {
+        id: lead.id,
+        name: lead.name,
+        sector_id: lead.sector_id ?? null,
+        size: lead.size,
+        location: lead.location,
+        website: lead.website,
+        description: lead.description,
+        short_description: lead.short_description ?? null,
+        keywords: lead.keywords ?? [],
+        tags: lead.tags,
+        score: lead.score,
+        ai_agent_lead_score: lead.ai_agent_lead_score,
+        social_presence: lead.social_presence ?? null,
+        social_urls: lead.social_urls ?? null,
+        registry_ids: lead.registry_ids ?? null
+      },
+      // 4) contacts (paid/enriched, plus org contacts if present)
+      contacts: {
+        enriched: paidContacts.map((c) => ({
+          id: c.id,
+          first_name: c.first_name,
+          last_name: c.last_name,
+          job_title: c.job_title,
+          email: c.email,
+          phone_number: c.phone_number,
+          linkedin_page: c.linkedin_page,
+          recommended: c.recommended,
+          enrichment_done: c.enrichment?.done ?? false
+        })),
+        org: orgContacts.map((c) => ({
+          id: c.id,
+          first_name: c.first_name,
+          last_name: c.last_name,
+          job_title: c.job_title,
+          email: c.email
+        }))
+      },
+      // 5) engagement — what humans/prior agent runs already did
+      engagement: {
+        liked: lead.liked,
+        disliked: lead.disliked,
+        new: lead.new ?? false,
+        recommended_contact_title: lead.recommended_contact_title ?? null,
+        recommended_contact: lead.recommended_contact ?? null,
+        notes_count: lead.notes_count ?? 0,
+        epilogue_actions_count: lead.epilogue_actions_count ?? 0,
+        prospecting_actions_count: lead.prospecting_actions_count ?? 0,
+        recent_notes: valOrNull(notesR)?.slice(0, 3) ?? [],
+        recent_epilogue: valOrNull(epilogueR)?.items?.slice(0, 3) ?? [],
+        recent_prospecting: valOrNull(prospR)?.items?.slice(0, 5) ?? []
+      },
+      _meta: {
+        region: client.region,
+        lens_id: lensId,
+        web_fetch_in_progress: webFetchR.status === "fulfilled" ? webFetchR.value?.in_progress : false
+      }
+    };
+  }
+};
+
+// ../core/dist/composite/recall-ordered-titles.js
+var recallOrderedTitles = {
+  name: "leadbay_recall_ordered_titles",
+  description: "Show job titles the org has previously enriched, so the agent can repeat the same titles for new leads (or skip already-saturated ones). Two implementation paths: (1) PREFERRED: a selection-scoped preview call that reads previously_enriched_titles from the backend (newer prod field). (2) FALLBACK: live aggregation across each lead's enriched contacts. The composite picks transparently. When to use: before leadbay_enrich_titles, to plan which titles to order. When NOT to use: when you already know the exact titles you want to enrich.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      leadIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs to query. Omit to use the current wishlist (top page)."
+      },
+      lensId: {
+        type: "number",
+        description: "Override the auto-resolved last-active lens when omitting leadIds (escape hatch)"
+      }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    let leadIds = params.leadIds;
+    if (!leadIds || leadIds.length === 0) {
+      const lensId = params.lensId ?? await client.resolveDefaultLens();
+      const wish = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=50&page=0`);
+      leadIds = wish.items.map((l) => l.id);
+    }
+    if (leadIds.length === 0) {
+      return { titles: [], source: "live_aggregate", note: "No candidate leads" };
+    }
+    await client.acquireSelectionLock();
+    try {
+      const qs = leadIds.map((id) => `leadIds=${encodeURIComponent(id)}`).join("&");
+      try {
+        await client.requestVoid("POST", `/leads/selection/select?${qs}`);
+        const preview = await client.request("POST", "/leads/selection/enrichment/preview", { titles: [] });
+        if (Array.isArray(preview.previously_enriched_titles) && preview.previously_enriched_titles.length > 0) {
+          return {
+            source: "preview_field",
+            titles: preview.previously_enriched_titles.map((t) => ({ title: t })),
+            available_in_selection: preview.title_suggestions ?? []
+          };
+        }
+      } catch (err) {
+        ctx?.logger?.warn?.(`recall_ordered_titles: preview path failed: ${err?.message ?? err?.code ?? err}`);
+      } finally {
+        try {
+          await client.requestVoid("POST", "/leads/selection/clear");
+        } catch (e) {
+          ctx?.logger?.warn?.(`recall_ordered_titles: selection clear failed: ${e?.message}`);
+        }
+      }
+    } finally {
+      client.releaseSelectionLock();
+    }
+    const titleStats = /* @__PURE__ */ new Map();
+    await Promise.all(leadIds.map(async (leadId) => {
+      try {
+        const contacts = await client.request("GET", `/leads/${leadId}/enrich/contacts?IncludeEnriched=true`);
+        const enriched = contacts.filter((c) => c.enrichment?.done && c.job_title);
+        const unenriched = contacts.filter((c) => !c.enrichment?.done && c.job_title);
+        const titlesEnrichedHere = new Set(enriched.map((c) => c.job_title));
+        for (const t of titlesEnrichedHere) {
+          const cur = titleStats.get(t) ?? {
+            title: t,
+            leads_with_enriched: 0,
+            total_enriched_contacts: 0,
+            leads_still_having_unenriched: 0
+          };
+          cur.leads_with_enriched += 1;
+          cur.total_enriched_contacts += enriched.filter((c) => c.job_title === t).length;
+          titleStats.set(t, cur);
+        }
+        for (const c of unenriched) {
+          const t = c.job_title;
+          const cur = titleStats.get(t);
+          if (cur)
+            cur.leads_still_having_unenriched += 1;
+        }
+      } catch (err) {
+        ctx?.logger?.warn?.(`recall_ordered_titles: contacts fetch failed for ${leadId}: ${err?.message}`);
+      }
+    }));
+    return {
+      source: "live_aggregate",
+      titles: [...titleStats.values()].sort((a, b) => b.total_enriched_contacts - a.total_enriched_contacts),
+      note: "Aggregated from individual leads' contacts (the backend's previously_enriched_titles field is not yet available). Once it ships, this composite switches to the cheaper preview-field path automatically."
+    };
+  }
+};
+
+// ../core/dist/composite/account-status.js
+var accountStatus = {
+  name: "leadbay_account_status",
+  description: "Show the user's account state \u2014 admin rights, language, last-active lens, current quota usage across daily/weekly/monthly windows for llm_completion / ai_rescore / web_fetch resources, and whether the org's intelligence is mid-regeneration. When to use: at the start of a session to know what the agent can/can't do, or after a 429 to explain to the user which resource window was exhausted and when it resets. When NOT to use: as a pre-flight gate before bulk ops \u2014 operations themselves return 429; this tool is for context, not gating.",
+  inputSchema: { type: "object", properties: {} },
+  execute: async (client, _params, ctx) => {
+    const me = await client.resolveMe();
+    let quota = null;
+    try {
+      quota = await client.request("GET", `/organizations/${me.organization.id}/quota_status`);
+    } catch (err) {
+      ctx?.logger?.warn?.(`account_status: quota_status failed: ${err?.message ?? err?.code ?? err}`);
+    }
+    return {
+      user: {
+        email: me.email ?? null,
+        name: me.name ?? null,
+        admin: me.admin ?? false,
+        manager: me.manager ?? false,
+        language: me.language ?? "en"
+      },
+      organization: {
+        id: me.organization.id,
+        name: me.organization.name,
+        ai_agent_enabled: me.organization.ai_agent_enabled ?? false,
+        computing_intelligence: me.organization.computing_intelligence ?? false,
+        plan: quota?.plan ?? me.organization.quota_plan ?? null
+      },
+      last_requested_lens: me.last_requested_lens ?? null,
+      // Quota goes here verbatim from /quota_status. Legacy freemium.* fields
+      // on /me are intentionally NOT surfaced — they're defunct (see
+      // SHAPE-DRIFT.md probe round 4).
+      quota,
+      _meta: {
+        region: client.region
+      }
+    };
+  }
+};
+
+// ../core/dist/composite/bulk-qualify-leads.js
+var PAGE_SIZE = 50;
+var DEFAULT_COUNT = 10;
+var MAX_COUNT = 25;
+var DEFAULT_PER_LEAD_BUDGET_MS = 9e4;
+var DEFAULT_TOTAL_BUDGET_MS = 5 * 6e4;
+var bulkQualifyLeads = {
+  name: "leadbay_bulk_qualify_leads",
+  description: "Pick the next N unqualified leads in the active lens and qualify them (run AI rescore + web fetch), polling until the answers are populated or a budget is exhausted. Already-qualified leads (those with a non-null ai_agent_lead_score) are silently no-ops on the backend, so this composite paginates past them to find fresh candidates. On 429 mid-fanout, stops launching but keeps polling already-launched leads. When to use: when the user wants more qualified leads than what's currently shown. When NOT to use: to qualify a single specific lead \u2014 that's leadbay_qualify_lead (granular, advanced).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      count: {
+        type: "number",
+        description: `How many fresh leads to qualify (default ${DEFAULT_COUNT}, max ${MAX_COUNT})`
+      },
+      leadIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Explicit lead UUIDs to qualify (skips the auto-pagination)"
+      },
+      lensId: {
+        type: "number",
+        description: "Lens id (escape hatch \u2014 defaults to active)"
+      },
+      per_lead_budget_ms: {
+        type: "number",
+        description: `Polling budget per lead in ms (default ${DEFAULT_PER_LEAD_BUDGET_MS})`
+      },
+      total_budget_ms: {
+        type: "number",
+        description: `Total polling budget in ms (default ${DEFAULT_TOTAL_BUDGET_MS})`
+      }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    const wantCount = Math.min(params.count ?? DEFAULT_COUNT, MAX_COUNT);
+    const perLeadBudget = params.per_lead_budget_ms ?? DEFAULT_PER_LEAD_BUDGET_MS;
+    const totalBudget = params.total_budget_ms ?? DEFAULT_TOTAL_BUDGET_MS;
+    const totalDeadline = Date.now() + totalBudget;
+    let candidates;
+    let exhausted = false;
+    let totalUnqualifiedFound = 0;
+    let lensId;
+    if (params.leadIds && params.leadIds.length > 0) {
+      candidates = params.leadIds;
+      lensId = params.lensId ?? await client.resolveDefaultLens();
+    } else {
+      lensId = params.lensId ?? await client.resolveDefaultLens();
+      candidates = [];
+      let page = 0;
+      while (candidates.length < wantCount) {
+        const wish = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=${PAGE_SIZE}&page=${page}`);
+        if (wish.items.length === 0) {
+          exhausted = true;
+          break;
+        }
+        const fresh = wish.items.filter((l) => l.ai_agent_lead_score == null && l.web_fetch_in_progress !== true);
+        totalUnqualifiedFound += fresh.length;
+        for (const lead of fresh) {
+          candidates.push(lead.id);
+          if (candidates.length >= wantCount)
+            break;
+        }
+        if (page >= wish.pagination.pages - 1) {
+          exhausted = true;
+          break;
+        }
+        page += 1;
+      }
+    }
+    if (candidates.length === 0) {
+      return {
+        qualified: [],
+        still_running: [],
+        failed: [],
+        quota_exceeded: false,
+        exhausted,
+        total_unqualified_found: totalUnqualifiedFound,
+        message: "No unqualified leads found in this lens \u2014 either all leads have been qualified, or the wishlist is still computing (check leadbay_account_status for computing_wishlist)."
+      };
+    }
+    const launched = [];
+    const failed = [];
+    let quotaExceeded = false;
+    for (const leadId of candidates) {
+      if (quotaExceeded)
+        break;
+      try {
+        await client.requestVoid("POST", `/leads/${leadId}/web_fetch?force_fetch=false`);
+        launched.push(leadId);
+      } catch (err) {
+        if (err?.code === "QUOTA_EXCEEDED") {
+          quotaExceeded = true;
+          ctx?.logger?.warn?.(`bulk_qualify_leads: 429 mid-fanout after launching ${launched.length}/${candidates.length} \u2014 stopping further launches but polling those already in flight`);
+        } else if (err?.code === "NOT_FOUND") {
+          failed.push({ lead_id: leadId, error: "lead not found" });
+        } else {
+          failed.push({
+            lead_id: leadId,
+            error: err?.message ?? err?.code ?? "unknown"
+          });
+        }
+      }
+    }
+    const results = await Promise.all(launched.map(async (leadId) => {
+      const leadDeadline = Math.min(Date.now() + perLeadBudget, totalDeadline);
+      let lastQual = null;
+      let lastWf = null;
+      while (Date.now() < leadDeadline) {
+        try {
+          const [wfR, qualR] = await Promise.allSettled([
+            client.request("GET", `/leads/${leadId}/web_fetch`),
+            client.request("GET", `/leads/${leadId}/ai_agent_responses`)
+          ]);
+          if (wfR.status === "fulfilled")
+            lastWf = wfR.value;
+          if (qualR.status === "fulfilled")
+            lastQual = qualR.value;
+          const done = lastWf !== null && lastWf.in_progress !== true && Array.isArray(lastQual) && lastQual.length > 0 && lastQual.every((r) => r.score != null);
+          if (done)
+            break;
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 5e3));
+      }
+      const stillRunning = lastWf?.in_progress === true || !lastQual || lastQual.length === 0 || lastQual.some((r) => r.score == null);
+      const responses = lastQual ?? [];
+      const scores = responses.map((r) => r.score).filter((s) => s != null);
+      const avg = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10 : null;
+      return {
+        lead_id: leadId,
+        qualification_summary: responses.length > 0 ? {
+          answered: responses.filter((r) => r.score != null).length,
+          total: responses.length,
+          avg_score_0_to_10: avg
+        } : null,
+        signals_count: lastWf?.content ? Object.values(lastWf.content).reduce((acc, arr) => acc + (Array.isArray(arr) ? arr.length : 0), 0) : null,
+        _stillRunning: stillRunning
+      };
+    }));
+    const qualified = results.filter((r) => !r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
+    const still_running = results.filter((r) => r._stillRunning).map(({ _stillRunning, ...rest }) => rest);
+    return {
+      qualified,
+      still_running,
+      failed,
+      quota_exceeded: quotaExceeded,
+      exhausted,
+      total_unqualified_found: totalUnqualifiedFound,
+      lens_id: lensId,
+      _meta: { region: client.region }
+    };
+  }
+};
+
+// ../core/dist/composite/enrich-titles.js
+var DEFAULT_CANDIDATE_COUNT = 25;
+var enrichTitles = {
+  name: "leadbay_enrich_titles",
+  description: "Order contact enrichments by job title across many leads. Two modes: (A) NO titles param \u2014 returns the available titles + Leadbay's title_suggestions + auto_included_titles + a count of enrichable contacts, so the agent can ask the user which titles to enrich. (B) titles given \u2014 calls preview, then launches if there's anything enrichable. On 429 returns {status:'quota_exceeded'} cleanly. Selection lifecycle is wrapped in a try/finally so the user's selection is left clean even on error. When to use: as the agent's go-to enrichment entry point. When NOT to use: to enrich a single contact \u2014 that's leadbay_enrich_contacts (granular).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      titles: {
+        type: "array",
+        items: { type: "string" },
+        description: "Job titles to enrich. Omit to discover what's available without launching."
+      },
+      leadIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Lead UUIDs to enrich. Omit to use the top page of the active lens's wishlist."
+      },
+      lensId: {
+        type: "number",
+        description: "Lens id (escape hatch \u2014 defaults to active)"
+      },
+      email: { type: "boolean", description: "Enrich emails (default true)" },
+      phone: { type: "boolean", description: "Enrich phone numbers (default false)" },
+      candidateCount: {
+        type: "number",
+        description: `When leadIds is omitted, how many top-of-wishlist leads to use (default ${DEFAULT_CANDIDATE_COUNT})`
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, don't launch \u2014 only preview."
+      }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    const email = params.email ?? true;
+    const phone = params.phone ?? false;
+    if (!email && !phone) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: "Either email or phone must be true",
+        hint: "Set email:true (most common) or phone:true"
+      };
+    }
+    let leadIds = params.leadIds;
+    if (!leadIds || leadIds.length === 0) {
+      const lensId = params.lensId ?? await client.resolveDefaultLens();
+      const cnt = params.candidateCount ?? DEFAULT_CANDIDATE_COUNT;
+      const wish = await client.request("GET", `/lenses/${lensId}/leads/wishlist?count=${Math.min(cnt, 50)}&page=0`);
+      leadIds = wish.items.map((l) => l.id);
+    }
+    if (leadIds.length === 0) {
+      return {
+        error: true,
+        code: "NO_CANDIDATES",
+        message: "No candidate leads",
+        hint: "Pass leadIds explicitly or wait for the wishlist to compute"
+      };
+    }
+    await client.acquireSelectionLock();
+    try {
+      const qs = leadIds.map((id) => `leadIds=${encodeURIComponent(id)}`).join("&");
+      await client.requestVoid("POST", `/leads/selection/select?${qs}`);
+      try {
+        const availableTitles = await client.request("GET", "/leads/selection/enrichment/job_titles");
+        if (!params.titles || params.titles.length === 0) {
+          let suggestions = [];
+          let autoIncluded = [];
+          let previouslyEnriched = [];
+          let enrichableContacts = 0;
+          try {
+            const prev = await client.request("POST", "/leads/selection/enrichment/preview", { titles: [] });
+            suggestions = prev.title_suggestions ?? [];
+            autoIncluded = prev.auto_included_titles ?? [];
+            previouslyEnriched = prev.previously_enriched_titles ?? [];
+            enrichableContacts = prev.enrichable_contacts;
+          } catch (e) {
+            ctx?.logger?.warn?.(`enrich_titles: 0-titles preview failed: ${e?.message}`);
+          }
+          return {
+            mode: "discover",
+            available_titles: availableTitles,
+            recommendations: suggestions,
+            auto_included: autoIncluded,
+            previously_enriched: previouslyEnriched,
+            enrichable_contacts: enrichableContacts,
+            selected_lead_count: leadIds.length,
+            next_action: "Pick titles to enrich and call leadbay_enrich_titles again with titles=[...]"
+          };
+        }
+        let preview;
+        try {
+          preview = await client.request("POST", "/leads/selection/enrichment/preview", { titles: params.titles });
+        } catch (err) {
+          if (err?.code === "QUOTA_EXCEEDED") {
+            return {
+              status: "quota_exceeded",
+              message: "Quota exceeded on preview",
+              retry_after_seconds: err?._meta?.retry_after ?? null
+            };
+          }
+          throw err;
+        }
+        if (preview.enrichable_contacts === 0) {
+          return {
+            mode: "preview_only",
+            preview,
+            launched: false,
+            message: "No enrichable contacts for the chosen titles. Try other titles from available_titles or recommendations.",
+            available_titles: availableTitles
+          };
+        }
+        if (params.dry_run) {
+          return {
+            mode: "dry_run",
+            preview,
+            launched: false,
+            would_launch: { titles: params.titles, email, phone }
+          };
+        }
+        try {
+          await client.requestVoid("POST", "/leads/selection/enrichment/launch", { titles: params.titles, email, phone });
+        } catch (err) {
+          if (err?.code === "QUOTA_EXCEEDED") {
+            return {
+              status: "quota_exceeded",
+              preview,
+              message: "Quota exceeded on launch",
+              retry_after_seconds: err?._meta?.retry_after ?? null
+            };
+          }
+          throw err;
+        }
+        return {
+          mode: "launched",
+          preview,
+          launched: true,
+          titles: params.titles,
+          email,
+          phone,
+          message: "Enrichment job launched. The Leadbay backend does not return a bulk_id (probed 2026-04-20) \u2014 track results by polling individual leads via leadbay_get_contacts after ~60s; contact.enrichment.done flips to true.",
+          next_action: "Wait ~60s, then call leadbay_research_lead or leadbay_get_contacts on the leads you care about."
+        };
+      } finally {
+        try {
+          await client.requestVoid("POST", "/leads/selection/clear");
+        } catch (e) {
+          ctx?.logger?.warn?.(`enrich_titles: selection.clear failed: ${e?.message ?? e?.code}`);
+        }
+      }
+    } finally {
+      client.releaseSelectionLock();
+    }
+  }
+};
+
+// ../core/dist/composite/adjust-audience.js
+function tokens(s) {
+  return s.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+function bestMatches(text, taxonomy) {
+  const want = new Set(tokens(text));
+  if (want.size === 0)
+    return [];
+  const ranked = taxonomy.map((s) => {
+    const have = new Set(tokens(s.name));
+    let overlap = 0;
+    for (const t of want)
+      if (have.has(t))
+        overlap += 1;
+    const score = overlap / Math.max(want.size, 1);
+    return { id: s.id, name: s.name, score };
+  }).filter((m) => m.score > 0).sort((a, b) => b.score - a.score);
+  return ranked.slice(0, 5);
+}
+async function resolveSectors(client, texts) {
+  const looksLikeId = (s) => /^\d+$/.test(s);
+  const direct = texts.filter(looksLikeId);
+  const free = texts.filter((s) => !looksLikeId(s));
+  if (free.length === 0)
+    return { resolved: direct, ambiguities: [] };
+  const me = await client.resolveMe().catch(() => null);
+  const lang = me?.language ?? "en";
+  const taxonomy = await client.request("GET", `/sectors/all?lang=${encodeURIComponent(lang)}&includeInvisible=false`);
+  const resolved = [...direct];
+  const ambiguities = [];
+  for (const text of free) {
+    const matches = bestMatches(text, taxonomy);
+    if (matches.length === 1 || matches.length >= 2 && matches[0].score >= 0.66 && matches[0].score - matches[1].score >= 0.34) {
+      resolved.push(matches[0].id);
+    } else {
+      ambiguities.push({ sector_text: text, matches });
+    }
+  }
+  return { resolved, ambiguities };
+}
+function mergeFilter(current, toAddSectors, toExcludeSectors, sizes) {
+  const items = current?.lens_filter?.items ?? [];
+  const item = items[0] ?? { criteria: [] };
+  const criteria = item.criteria ? [...item.criteria] : [];
+  if (toAddSectors.length > 0) {
+    const idx = criteria.findIndex((c) => c.type === "sector_ids" && !c.is_excluded);
+    if (idx >= 0) {
+      const cur = criteria[idx];
+      const merged = Array.from(/* @__PURE__ */ new Set([...cur.sectors ?? [], ...toAddSectors]));
+      criteria[idx] = { ...cur, sectors: merged };
+    } else {
+      criteria.push({
+        type: "sector_ids",
+        is_excluded: false,
+        sectors: toAddSectors
+      });
+    }
+  }
+  if (toExcludeSectors.length > 0) {
+    const idx = criteria.findIndex((c) => c.type === "sector_ids" && c.is_excluded);
+    if (idx >= 0) {
+      const cur = criteria[idx];
+      const merged = Array.from(/* @__PURE__ */ new Set([...cur.sectors ?? [], ...toExcludeSectors]));
+      criteria[idx] = { ...cur, sectors: merged };
+    } else {
+      criteria.push({
+        type: "sector_ids",
+        is_excluded: true,
+        sectors: toExcludeSectors
+      });
+    }
+  }
+  if (sizes && sizes.length > 0) {
+    const idx = criteria.findIndex((c) => c.type === "size");
+    if (idx >= 0) {
+      criteria[idx] = { type: "size", is_excluded: false, sizes };
+    } else {
+      criteria.push({ type: "size", is_excluded: false, sizes });
+    }
+  }
+  return {
+    lens_filter: { items: [{ criteria }] },
+    locations: current.locations ?? { results: [], parents: [] }
+  };
+}
+var adjustAudience = {
+  name: "leadbay_adjust_audience",
+  description: "Restrict (or expand) the lens audience by sector / size. Free-text sectors are auto-resolved against the sector taxonomy; ambiguous matches are surfaced to the agent rather than guessed silently. Permission routing is hidden: the default lens auto-clones to a new user lens; an org-level lens defaults to a per-user draft (admins can override with save_for_org:true). Filter MERGES with existing criteria (unrelated criteria are not dropped). When to use: when the user wants to see different kinds of leads (sector / size / etc.). When NOT to use: to refine BEYOND firmographics \u2014 that's leadbay_refine_prompt.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      sectors: {
+        type: "array",
+        items: { type: "string" },
+        description: "Sector free-text (e.g. ['Healthcare', 'Engineering']) or ids \u2014 auto-resolved"
+      },
+      sector_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Explicit sector ids (skips taxonomy lookup)"
+      },
+      exclude_sectors: {
+        type: "array",
+        items: { type: "string" },
+        description: "Sectors to exclude (free text or ids)"
+      },
+      sizes: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { min: { type: "number" }, max: { type: "number" } }
+        },
+        description: "Company size buckets, e.g. [{min:30,max:300}]"
+      },
+      lensId: { type: "number", description: "Lens id (escape hatch)" },
+      save_for_org: {
+        type: "boolean",
+        description: "Admin only \u2014 propagate the change to the org-level lens for everyone (default false: per-user draft)"
+      },
+      newLensName: {
+        type: "string",
+        description: "Name to use when this composite has to clone the default lens (otherwise auto-named)"
+      }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    const me = await client.resolveMe();
+    const isAdmin = me.admin === true;
+    const startingLensId = params.lensId ?? me.last_requested_lens ?? await client.resolveDefaultLens();
+    const includeTexts = [
+      ...params.sectors ?? [],
+      ...params.sector_ids ?? []
+    ];
+    const excludeTexts = params.exclude_sectors ?? [];
+    const includeRes = await resolveSectors(client, includeTexts);
+    const excludeRes = await resolveSectors(client, excludeTexts);
+    const ambiguities = [
+      ...includeRes.ambiguities,
+      ...excludeRes.ambiguities
+    ];
+    if (ambiguities.length > 0) {
+      return {
+        status: "ambiguous_sectors",
+        sector_ambiguities: ambiguities,
+        message: "One or more sector names matched multiple sectors. Pick from the matches and re-call with sector_ids=..."
+      };
+    }
+    const lens = await client.request("GET", `/lenses/${startingLensId}`);
+    const currentFilter = await client.request("GET", `/lenses/${startingLensId}/filter`);
+    const merged = mergeFilter(currentFilter, includeRes.resolved, excludeRes.resolved, params.sizes);
+    const isDefault = lens.is_default || lens.default;
+    const isUserLevel = lens.user_id != null;
+    const isOrgLevel = !isUserLevel && !isDefault;
+    let targetLensId = startingLensId;
+    let wasDraft = false;
+    let wasNew = false;
+    if (isDefault) {
+      const name = params.newLensName ?? `Custom audience \u2014 ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
+      const newLens = await client.request("POST", "/lenses", {
+        base: startingLensId,
+        name
+      });
+      targetLensId = newLens.id;
+      wasNew = true;
+      await client.requestVoid("POST", `/lenses/${targetLensId}/filter`, merged);
+      await client.requestVoid("POST", `/lenses/${targetLensId}/update_last_requested`);
+    } else if (isUserLevel) {
+      try {
+        await client.requestVoid("POST", `/lenses/${startingLensId}/filter`, merged);
+      } catch (err) {
+        if (err?.code === "FORBIDDEN") {
+          wasDraft = true;
+          const draft = await client.request("POST", `/lenses/${startingLensId}/draft`);
+          targetLensId = draft.id;
+          await client.requestVoid("POST", `/lenses/${targetLensId}/filter`, merged);
+          await client.requestVoid("POST", `/lenses/${targetLensId}/update_last_requested`);
+        } else {
+          throw err;
+        }
+      }
+    } else if (isOrgLevel) {
+      const goDraft = !isAdmin || !params.save_for_org;
+      if (goDraft) {
+        wasDraft = true;
+        const draft = await client.request("POST", `/lenses/${startingLensId}/draft`);
+        targetLensId = draft.id;
+        try {
+          await client.requestVoid("POST", `/lenses/${targetLensId}/filter`, merged);
+        } catch (err) {
+          ctx?.logger?.warn?.(`adjust_audience: filter on draft ${targetLensId} failed: ${err?.message}`);
+          try {
+            await client.requestVoid("DELETE", `/lenses/${targetLensId}`);
+          } catch {
+            return {
+              error: true,
+              code: "ORPHAN_DRAFT",
+              message: `Draft ${targetLensId} created but filter update failed; draft cleanup also failed`,
+              hint: `Manually delete draft lens ${targetLensId} via the Leadbay UI`,
+              orphan_draft_id: targetLensId
+            };
+          }
+          throw err;
+        }
+        await client.requestVoid("POST", `/lenses/${targetLensId}/update_last_requested`);
+      } else {
+        try {
+          await client.requestVoid("POST", `/lenses/${startingLensId}/filter`, merged);
+        } catch (err) {
+          throw err;
+        }
+      }
+    }
+    client.invalidateMe();
+    client.invalidateDefaultLens();
+    return {
+      status: "applied",
+      lens_used: {
+        id: targetLensId,
+        name: lens.name,
+        was_draft: wasDraft,
+        was_new: wasNew,
+        save_for_org: params.save_for_org === true && isAdmin && isOrgLevel
+      },
+      filter_applied: merged,
+      message: wasDraft ? "Applied to your personal draft of the org lens (your view only)." : wasNew ? `Created a new user-level lens "${lens.name}" with the filter (you can rename via leadbay_update_lens).` : "Applied directly to the lens.",
+      _meta: { region: client.region }
+    };
+  }
+};
+
+// ../core/dist/composite/refine-prompt.js
+var DEFAULT_POLL_ATTEMPTS = 2;
+var DEFAULT_POLL_GAP_MS = 5e3;
+var refinePrompt = {
+  name: "leadbay_refine_prompt",
+  description: "Refine the kind of leads Leadbay surfaces, beyond firmographics. Free-text instruction (e.g. 'focus on hospitals running their own IT'). Sets the org's user_prompt; if the new prompt produces ambiguous criteria, Leadbay raises a clarification question, which this composite polls for and surfaces. Admin-only on the backend (will return 403 for non-admins). When to use: when audience filters (leadbay_adjust_audience) aren't enough. When NOT to use: to answer a pending clarification \u2014 that's leadbay_answer_clarification.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      prompt: { type: "string", description: "Refinement instruction (free text)" },
+      clarification_poll_attempts: {
+        type: "number",
+        description: `How many times to poll for a clarification after setting (default ${DEFAULT_POLL_ATTEMPTS})`
+      },
+      clarification_poll_gap_ms: {
+        type: "number",
+        description: `Gap between polls in ms (default ${DEFAULT_POLL_GAP_MS})`
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, return the call shape WITHOUT setting the prompt"
+      }
+    },
+    required: ["prompt"]
+  },
+  execute: async (client, params, ctx) => {
+    const me = await client.resolveMe();
+    if (me.admin !== true) {
+      return {
+        error: true,
+        code: "FORBIDDEN",
+        message: "leadbay_refine_prompt requires admin rights on the org",
+        hint: "Ask your Leadbay org admin to set the refinement prompt, or use leadbay_adjust_audience for firmographic changes"
+      };
+    }
+    const orgId = me.organization.id;
+    if (params.dry_run) {
+      return {
+        dry_run: true,
+        would_call: {
+          method: "POST",
+          path: `/organizations/${orgId}/user_prompt`,
+          body: { prompt: params.prompt }
+        }
+      };
+    }
+    const postedAt = Date.now();
+    const STALE_GUARD_MS = 5e3;
+    await client.requestVoid("POST", `/organizations/${orgId}/user_prompt`, {
+      prompt: params.prompt
+    });
+    client.invalidateMe();
+    const attempts = params.clarification_poll_attempts ?? DEFAULT_POLL_ATTEMPTS;
+    const gap = params.clarification_poll_gap_ms ?? DEFAULT_POLL_GAP_MS;
+    let clarification = null;
+    for (let i = 0; i < attempts; i++) {
+      await new Promise((r) => setTimeout(r, gap));
+      try {
+        const c = await client.request("GET", `/organizations/${orgId}/clarifications`);
+        if (c) {
+          if (c.created_at) {
+            const createdMs = Date.parse(c.created_at);
+            if (Number.isFinite(createdMs) && createdMs < postedAt - STALE_GUARD_MS) {
+              ctx?.logger?.warn?.(`refine_prompt: stale clarification (created_at=${c.created_at}, posted=${new Date(postedAt).toISOString()}) \u2014 ignoring`);
+              continue;
+            }
+          }
+          clarification = c;
+          break;
+        }
+      } catch (err) {
+        ctx?.logger?.warn?.(`refine_prompt: clarification poll error: ${err?.message}`);
+      }
+    }
+    if (clarification) {
+      return {
+        status: "clarification_pending",
+        clarification,
+        next_action: "Call leadbay_answer_clarification with option_id (preferred) or text_answer to disambiguate",
+        _meta: { region: client.region }
+      };
+    }
+    return {
+      status: "applied",
+      computing_intelligence: true,
+      message: "Prompt set. Leadbay is regenerating intelligence; new leads will reflect the refinement shortly. Check leadbay_account_status to monitor computing_intelligence.",
+      _meta: { region: client.region }
+    };
+  }
+};
+
+// ../core/dist/composite/answer-clarification.js
+var answerClarification = {
+  name: "leadbay_answer_clarification",
+  description: "Answer the pending clarification question Leadbay raised after a refine_prompt. The answer is stored as the new user_prompt and triggers regeneration. Pass option_id (preferred \u2014 pick from the offered options) or text_answer (free-text). Admin-only. When to use: after leadbay_refine_prompt returns status='clarification_pending'. When NOT to use: to set a brand-new prompt \u2014 use leadbay_refine_prompt.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      option_id: { type: "string", description: "Id of one of the clarification's options" },
+      text_answer: { type: "string", description: "Free-text answer (overrides option_id)" }
+    }
+  },
+  execute: async (client, params, ctx) => {
+    if (!params.option_id && !params.text_answer) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: "Provide option_id or text_answer",
+        hint: "Call leadbay_get_clarification first to see the options"
+      };
+    }
+    const me = await client.resolveMe();
+    if (me.admin !== true) {
+      return {
+        error: true,
+        code: "FORBIDDEN",
+        message: "Answering clarifications requires admin rights",
+        hint: "Ask your Leadbay org admin to answer the clarification"
+      };
+    }
+    const orgId = me.organization.id;
+    const pending = await client.request("GET", `/organizations/${orgId}/clarifications`);
+    if (!pending) {
+      return {
+        status: "no_pending_clarification",
+        hint: "There's no pending clarification \u2014 either it was already answered or none was raised. Use leadbay_refine_prompt to set a new prompt."
+      };
+    }
+    const body = {};
+    if (params.text_answer)
+      body.text_answer = params.text_answer;
+    if (params.option_id)
+      body.option_id = params.option_id;
+    await client.requestVoid("POST", `/organizations/${orgId}/pick_clarification`, body);
+    client.invalidateMe();
+    return {
+      status: "answered",
+      recorded_as_user_prompt: true,
+      message: "Answer recorded. Leadbay is regenerating intelligence based on it. Check leadbay_account_status for computing_intelligence.",
+      _meta: { region: client.region }
+    };
+  }
+};
+
+// ../core/dist/composite/report-outreach.js
+var VALID_SOURCES = /* @__PURE__ */ new Set([
+  "gmail_message_id",
+  "calendar_event_id",
+  "user_confirmed"
+]);
+function formatNoteWithVerification(note, v) {
+  return `${note}
+
+\u2014 logged by AI agent (verification: ${v.source}=${v.ref})`;
+}
+var reportOutreach = {
+  name: "leadbay_report_outreach",
+  description: "Log an outreach action (email, call, message, meeting) on a lead so the human team using Leadbay sees the progress in their UI. Writes a NOTE on the lead and (optionally) sets an EPILOGUE status (still chasing, meeting booked, etc.). VERIFICATION REQUIRED: every call must include verification={source: 'gmail_message_id'|'calendar_event_id'|'user_confirmed', ref: '<id-or-confirmation>'} to prevent hallucinated outreach poisoning the pipeline. The verification is appended to the note body. Bulk variant: pass lead_ids=[uuid,...] instead of lead_id (epilogue is bulk-native; notes fan out per-lead). When to use: AFTER actually emailing/calling/meeting/messaging a contact, OR after a substantive decision the user wants logged (skip, save, hand off). When NOT to use: BEFORE doing the outreach (use dry_run:true to validate args first); without verification (call will be rejected); from a flow where the user did not consent to having actions logged automatically.",
+  optional: true,
+  write: true,
+  inputSchema: {
+    type: "object",
+    properties: {
+      lead_id: { type: "string", description: "Single lead UUID (use lead_ids for bulk)" },
+      lead_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Bulk: many lead UUIDs (epilogue applies to all; notes fan out)"
+      },
+      note: {
+        type: "string",
+        description: "1-2 sentence summary of what was done (e.g. 'Sent intro email to CTO citing Hornsea 3 contract')"
+      },
+      epilogue_status: {
+        type: "string",
+        description: "Optional: STILL_CHASING | COULD_NOT_REACH_STILL_TRYING | INTEREST_VALIDATED_OR_MEETING_PLANED | NOT_INTERESTED_LOST"
+      },
+      verification: {
+        type: "object",
+        description: "REQUIRED. Proof the action actually happened. source: gmail_message_id|calendar_event_id|user_confirmed. ref: the message id, event id, or the user's confirming text.",
+        properties: {
+          source: { type: "string" },
+          ref: { type: "string" }
+        },
+        required: ["source", "ref"]
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, return what WOULD be called without writing anything"
+      }
+    },
+    required: ["note", "verification"]
+  },
+  execute: async (client, params, ctx) => {
+    if (!params.verification || !params.verification.source || !params.verification.ref) {
+      return {
+        error: true,
+        code: "VERIFICATION_REQUIRED",
+        message: "report_outreach requires verification={source, ref} on every call. This prevents hallucinated outreach from poisoning the pipeline.",
+        hint: "Provide verification.source as one of: gmail_message_id (the Gmail message id from sending), calendar_event_id (the event id from booking), or user_confirmed (set verification.ref to the user's literal confirmation in chat)."
+      };
+    }
+    if (!VALID_SOURCES.has(params.verification.source)) {
+      return {
+        error: true,
+        code: "BAD_VERIFICATION_SOURCE",
+        message: `verification.source must be one of: gmail_message_id, calendar_event_id, user_confirmed (got: ${params.verification.source})`,
+        hint: "Use 'user_confirmed' with verification.ref set to the user's literal text if you don't have a Gmail/Calendar id"
+      };
+    }
+    if (!params.lead_id && (!params.lead_ids || params.lead_ids.length === 0)) {
+      return {
+        error: true,
+        code: "BAD_INPUT",
+        message: "Provide lead_id (single) or lead_ids (bulk)",
+        hint: "lead_id for one lead; lead_ids: [uuid, ...] for many"
+      };
+    }
+    const noteBody = formatNoteWithVerification(params.note, params.verification);
+    let epilogueWire = null;
+    if (params.epilogue_status) {
+      const w = EPILOGUE_LABEL_MAP[params.epilogue_status];
+      if (!w) {
+        return {
+          error: true,
+          code: "BAD_INPUT",
+          message: `Unknown epilogue_status: ${params.epilogue_status}`,
+          hint: `Use one of: STILL_CHASING, COULD_NOT_REACH_STILL_TRYING, INTEREST_VALIDATED_OR_MEETING_PLANED, NOT_INTERESTED_LOST`
+        };
+      }
+      epilogueWire = w;
+    }
+    const targetLeads = params.lead_ids ?? [params.lead_id];
+    if (params.dry_run) {
+      return {
+        dry_run: true,
+        would_write_notes: targetLeads.map((id) => ({
+          method: "POST",
+          path: `/leads/${id}/notes`,
+          body: { note: noteBody }
+        })),
+        would_set_epilogue: epilogueWire ? {
+          method: "POST",
+          path: "/leads/epilogue",
+          body: { lead_ids: targetLeads, status: epilogueWire }
+        } : null
+      };
+    }
+    const noteResults = await Promise.all(targetLeads.map(async (leadId) => {
+      try {
+        const note = await client.request("POST", `/leads/${leadId}/notes`, { note: noteBody });
+        return { lead_id: leadId, ok: true, note_id: note.id };
+      } catch (err) {
+        return {
+          lead_id: leadId,
+          ok: false,
+          error: err?.message ?? err?.code ?? String(err)
+        };
+      }
+    }));
+    let epilogueResult = { applied: false };
+    if (epilogueWire) {
+      try {
+        await client.requestVoid("POST", "/leads/epilogue", {
+          lead_ids: targetLeads,
+          status: epilogueWire
+        });
+        epilogueResult = { applied: true };
+      } catch (err) {
+        epilogueResult = {
+          applied: false,
+          error: err?.message ?? err?.code ?? String(err)
+        };
+        ctx?.logger?.warn?.(`report_outreach: epilogue failed: ${epilogueResult.error}`);
+      }
+    }
+    return {
+      notes: {
+        succeeded: noteResults.filter((r) => r.ok).map((r) => ({ lead_id: r.lead_id, note_id: r.note_id })),
+        failed: noteResults.filter((r) => !r.ok).map((r) => ({ lead_id: r.lead_id, error: r.error }))
+      },
+      epilogue: {
+        status: epilogueWire,
+        ...epilogueResult
+      },
+      verification: params.verification,
+      _meta: { region: client.region }
+    };
+  }
+};
+
+// ../core/dist/index.js
+var granularReadTools = [
+  listLenses,
+  discoverLeads,
+  getLeadProfile,
+  getLeadActivities,
+  getTasteProfile,
+  getContacts,
+  getQuota,
+  getLensFilter,
+  getLensScoring,
+  listSectors,
+  getUserPrompt,
+  getClarification,
+  getLeadNotes,
+  getEpilogueResponses,
+  getProspectingActions,
+  getWebFetch,
+  getSelectionIds,
+  getEnrichmentJobTitles
+];
+var granularWriteTools = [
+  qualifyLead,
+  enrichContacts,
+  addNote,
+  selectLeads,
+  deselectLeads,
+  clearSelection,
+  setActiveLens,
+  createLens,
+  updateLens,
+  updateLensFilter,
+  createLensDraft,
+  promoteLens,
+  setUserPrompt,
+  clearUserPrompt,
+  pickClarification,
+  dismissClarification,
+  setEpilogueStatus,
+  removeEpilogue,
+  previewBulkEnrichment,
+  launchBulkEnrichment
+];
+var granularTools = [
+  login,
+  ...granularReadTools,
+  ...granularWriteTools
+];
+granularTools.forEach((t) => {
+  t.advanced = true;
+});
+var compositeReadTools = [
+  pullLeads,
+  researchLead,
+  recallOrderedTitles,
+  accountStatus,
+  // Keep the existing composites available too.
+  researchCompany,
+  prepareOutreach
+];
+var compositeWriteTools = [
+  bulkQualifyLeads,
+  enrichTitles,
+  adjustAudience,
+  refinePrompt,
+  answerClarification,
+  reportOutreach
+];
+var compositeTools = [
+  ...compositeReadTools,
+  ...compositeWriteTools
+];
+var tools = [...compositeTools, ...granularTools];
+
+export {
+  REGIONS,
+  createClient,
+  resolveRegion,
+  getMockJournal,
+  clearMockJournal,
+  LeadbayClient,
+  login,
+  listLenses,
+  discoverLeads,
+  getLeadProfile,
+  getContacts,
+  getQuota,
+  getTasteProfile,
+  qualifyLead,
+  enrichContacts,
+  addNote,
+  getLeadActivities,
+  getLensFilter,
+  getLensScoring,
+  listSectors,
+  getUserPrompt,
+  getClarification,
+  getLeadNotes,
+  getEpilogueResponses,
+  getProspectingActions,
+  getWebFetch,
+  getSelectionIds,
+  getEnrichmentJobTitles,
+  selectLeads,
+  deselectLeads,
+  clearSelection,
+  setActiveLens,
+  createLens,
+  updateLens,
+  updateLensFilter,
+  createLensDraft,
+  promoteLens,
+  setUserPrompt,
+  clearUserPrompt,
+  pickClarification,
+  dismissClarification,
+  setEpilogueStatus,
+  removeEpilogue,
+  previewBulkEnrichment,
+  launchBulkEnrichment,
+  researchCompany,
+  prepareOutreach,
+  pullLeads,
+  researchLead,
+  recallOrderedTitles,
+  accountStatus,
+  bulkQualifyLeads,
+  enrichTitles,
+  adjustAudience,
+  refinePrompt,
+  answerClarification,
+  reportOutreach,
+  granularReadTools,
+  granularWriteTools,
+  granularTools,
+  compositeReadTools,
+  compositeWriteTools,
+  compositeTools,
+  tools
+};