@leadbay/mcp 0.10.0 → 0.11.0

package/dist/bin.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  LeadbayClient,
   compositeReadTools,
   compositeWriteTools,
   createClient,
@@ -8,7 +9,7 @@ import {
   granularReadTools,
   granularWriteTools,
   resolveRegion
-} from "./chunk-F3EWCHME.js";
+} from "./chunk-MZZMIZXA.js";
 
 // src/bin.ts
 import { realpathSync } from "fs";
@@ -128,25 +129,20 @@ If \`qualification_summary.answered == 0\` or \`avg_qualification_boost\` is nul
 
 **Column 3 \u2014 Contact**
 
-\`[Contact name](LINK) \xB7 short job title\`. See linking/contact-linkedin for LINK priority and the \xB0-flag fallback.
+\`[Contact name](LINK) \xB7 short job title\`. The \`[Contact name](LINK)\` markdown link wrapping is mandatory \u2014 never render the name as plain text. See linking/contact-linkedin for the URL priority (real profile \u2192 constructed people-search) and the \xB0-flag fallback.
 
 **Hide from the user (never include in any cell):** \`id\`, \`location.pos\`, \`location.country\` (unless city/state both missing), \`sector_id\`, \`is_hq\`, \`web_fetch_in_progress\`, \`enrichment_in_progress\`, \`highlighted_fields\`, \`custom_fields\`, \`contacts_count\` when 0, \`notes_count\` / \`epilogue_actions_count\` / \`prospecting_actions_count\` when 0, \`stale_at\`, \`deal_insights\`, \`social_presence\` booleans (except as the \xB0-flag signal), \`need_attention\` flags, any field whose value is the string \`"null"\`.
 
 ## Linking a contact's name
 
-Two LinkedIn URLs exist and must never be conflated: the **company's** LinkedIn page and an **individual person's** profile.
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
 
-When the response carries a real contact LinkedIn URL \u2014 \`contact.linkedin_page\` is a string that starts with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it) \u2014 link the contact's name to that URL.
+URL priority (first applicable wins):
 
-Otherwise fall back to a LinkedIn people-search URL:
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
 
-\`\`\`
-https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>
-\`\`\`
-
-URL-encode the params. Strip Inc / LLC / Corp / Ltd / GmbH suffixes from the company name. Append a trailing \` \xB0\` to the rendered name ONLY when the fallback is in use AND \`social_presence.linkedin == false\` (no company LinkedIn \u2192 search may not resolve). Never append \`\xB0\` when a real \`linkedin_page\` was used.
-
-Never link a person's name to the company's LinkedIn page (and vice versa). The two surfaces are different \u2014 conflating them quietly degrades the workflow.
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
 
 ## Linking the company
 
@@ -585,25 +581,20 @@ If \`qualification_summary.answered == 0\` or \`avg_qualification_boost\` is nul
 
 **Column 3 \u2014 Contact**
 
-\`[Contact name](LINK) \xB7 short job title\`. See linking/contact-linkedin for LINK priority and the \xB0-flag fallback.
+\`[Contact name](LINK) \xB7 short job title\`. The \`[Contact name](LINK)\` markdown link wrapping is mandatory \u2014 never render the name as plain text. See linking/contact-linkedin for the URL priority (real profile \u2192 constructed people-search) and the \xB0-flag fallback.
 
 **Hide from the user (never include in any cell):** \`id\`, \`location.pos\`, \`location.country\` (unless city/state both missing), \`sector_id\`, \`is_hq\`, \`web_fetch_in_progress\`, \`enrichment_in_progress\`, \`highlighted_fields\`, \`custom_fields\`, \`contacts_count\` when 0, \`notes_count\` / \`epilogue_actions_count\` / \`prospecting_actions_count\` when 0, \`stale_at\`, \`deal_insights\`, \`social_presence\` booleans (except as the \xB0-flag signal), \`need_attention\` flags, any field whose value is the string \`"null"\`.
 
 ## Linking a contact's name
 
-Two LinkedIn URLs exist and must never be conflated: the **company's** LinkedIn page and an **individual person's** profile.
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
 
-When the response carries a real contact LinkedIn URL \u2014 \`contact.linkedin_page\` is a string that starts with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it) \u2014 link the contact's name to that URL.
+URL priority (first applicable wins):
 
-Otherwise fall back to a LinkedIn people-search URL:
-
-\`\`\`
-https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>
-\`\`\`
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
 
-URL-encode the params. Strip Inc / LLC / Corp / Ltd / GmbH suffixes from the company name. Append a trailing \` \xB0\` to the rendered name ONLY when the fallback is in use AND \`social_presence.linkedin == false\` (no company LinkedIn \u2192 search may not resolve). Never append \`\xB0\` when a real \`linkedin_page\` was used.
-
-Never link a person's name to the company's LinkedIn page (and vice versa). The two surfaces are different \u2014 conflating them quietly degrades the workflow.
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
 
 ## Linking the company
 
@@ -718,19 +709,14 @@ If \`qualification[]\` is non-empty, append one collapsed line: \`"Qualification
 
 ## Linking a contact's name
 
-Two LinkedIn URLs exist and must never be conflated: the **company's** LinkedIn page and an **individual person's** profile.
-
-When the response carries a real contact LinkedIn URL \u2014 \`contact.linkedin_page\` is a string that starts with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it) \u2014 link the contact's name to that URL.
-
-Otherwise fall back to a LinkedIn people-search URL:
+**MANDATORY: every contact name in your output \u2014 table cells, prose, headers, "Reach <Name>" callouts \u2014 MUST be wrapped in markdown link syntax \`[Name](URL)\`. Never render a contact name as bare text. A plain-text name is a broken contact card; the underlined name is the user's primary affordance for "take me to this person's profile". No "no URL available" exception \u2014 the search URL below is always constructable from name + company.**
 
-\`\`\`
-https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>
-\`\`\`
+URL priority (first applicable wins):
 
-URL-encode the params. Strip Inc / LLC / Corp / Ltd / GmbH suffixes from the company name. Append a trailing \` \xB0\` to the rendered name ONLY when the fallback is in use AND \`social_presence.linkedin == false\` (no company LinkedIn \u2192 search may not resolve). Never append \`\xB0\` when a real \`linkedin_page\` was used.
+1. **Real profile** \u2014 \`contact.linkedin_page\` when it's a string starting with \`https://\` (the MCP coerces the legacy literal \`"null"\` string to real null before you see it).
+2. **Constructed people-search** \u2014 \`https://www.linkedin.com/search/results/people/?keywords=<First>+<Last>+<Company>\`. URL-encode params. Strip Inc / LLC / Corp / Ltd / GmbH / Co / S.A. / S.L. / PLC / AG / SAS / SARL suffixes from the company. Append a trailing \` \xB0\` to the rendered name ONLY when this fallback is in use AND \`social_presence.linkedin == false\`. Never append \`\xB0\` when a real \`linkedin_page\` was used.
 
-Never link a person's name to the company's LinkedIn page (and vice versa). The two surfaces are different \u2014 conflating them quietly degrades the workflow.
+Never link a person's name to the company's LinkedIn page (and vice versa) \u2014 the two surfaces are different and conflating them quietly degrades the workflow.
 
 ## Linking the company
 
@@ -1032,6 +1018,12 @@ var EMBEDDED_SENTRY_DSN = "https://301f1c433433b76132956ed5415bea19@o45058744368
 var EV_TOOL_CALL = "mcp tool called";
 var EV_QUOTA_HIT = "mcp quota hit";
 var EV_TOPUP_LINK = "mcp topup link created";
+var EV_STARTUP = "mcp startup";
+var EV_MCP_UPDATE_CHECK = "mcp update check";
+var EV_MCP_UPDATE_PROMPTED = "mcp update prompted";
+var EV_MCP_UPDATE_INSTALL_CLICKED = "mcp update install_clicked";
+var EV_MCP_UPDATE_DISMISSED = "mcp update dismissed";
+var EV_MCP_VERSION_UPDATED = "mcp version updated";
 
 // src/telemetry.ts
 var NOOP_TELEMETRY = {
@@ -1043,8 +1035,20 @@ var NOOP_TELEMETRY = {
   },
   captureTopupLink: () => {
   },
+  captureStartup: () => {
+  },
   captureException: () => {
   },
+  captureUpdateCheck: () => {
+  },
+  captureUpdatePrompted: () => {
+  },
+  captureUpdateInstallClicked: () => {
+  },
+  captureUpdateDismissed: () => {
+  },
+  captureVersionUpdated: () => {
+  },
   shutdown: async () => {
   }
 };
@@ -1088,7 +1092,12 @@ function initTelemetry(opts) {
         profilesSampleRate: 0,
         defaultIntegrations: false,
         integrations: [Sentry.httpIntegration()],
-        sendDefaultPii: false
+        sendDefaultPii: false,
+        // Tag every captured event with the surface so Sentry views can
+        // split MCP issues from web-app issues without per-call work.
+        initialScope: {
+          tags: { source: "mcp" }
+        }
       });
       sentryReady = true;
     }
@@ -1105,6 +1114,11 @@ function initTelemetry(opts) {
   const pendingEvents = [];
   let region = "unknown";
   const baseProps = () => ({
+    // Always tag MCP-originated events so PostHog dashboards can split
+    // MCP usage from the web app and any future surfaces. The value
+    // ("mcp") is the canonical source identifier — match it in any
+    // PostHog filter or insight that should isolate the MCP surface.
+    source: "mcp",
     mcp_version: version,
     node_version: process.versions.node,
     platform: process.platform,
@@ -1204,6 +1218,24 @@ function initTelemetry(opts) {
     captureTopupLink(props) {
       emit(EV_TOPUP_LINK, { ...props });
     },
+    captureStartup(props) {
+      emit(EV_STARTUP, { ...props });
+    },
+    captureUpdateCheck(props) {
+      emit(EV_MCP_UPDATE_CHECK, { ...props });
+    },
+    captureUpdatePrompted(props) {
+      emit(EV_MCP_UPDATE_PROMPTED, { ...props });
+    },
+    captureUpdateInstallClicked(props) {
+      emit(EV_MCP_UPDATE_INSTALL_CLICKED, { ...props });
+    },
+    captureUpdateDismissed(props) {
+      emit(EV_MCP_UPDATE_DISMISSED, { ...props });
+    },
+    captureVersionUpdated(props) {
+      emit(EV_MCP_VERSION_UPDATED, { ...props });
+    },
     captureException(err, ctx) {
       if (!sentryReady) return;
       try {
@@ -1227,6 +1259,327 @@ function initTelemetry(opts) {
   };
 }
 
+// src/update-check.ts
+var cachedInfo = null;
+var checkInFlight = false;
+function getCachedUpdateInfo() {
+  return cachedInfo;
+}
+var RELEASES_LATEST_URL = "https://api.github.com/repos/leadbay/leadclaw/releases/latest";
+var CHECK_THROTTLE_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 5e3;
+var USER_AGENT = "leadbay-mcp-update-check";
+function parseTagName(tag) {
+  const stripped = tag.replace(/^mcp-v?/, "").replace(/^v/, "");
+  if (!/^\d+\.\d+\.\d+/.test(stripped)) return null;
+  return stripped;
+}
+function compareSemver(a, b) {
+  const [aCore, aPre] = a.split("-", 2);
+  const [bCore, bPre] = b.split("-", 2);
+  const aParts = aCore.split(".").map((n) => parseInt(n, 10));
+  const bParts = bCore.split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < 3; i++) {
+    const av = aParts[i] ?? 0;
+    const bv = bParts[i] ?? 0;
+    if (av > bv) return 1;
+    if (av < bv) return -1;
+  }
+  if (!aPre && !bPre) return 0;
+  if (!aPre && bPre) return 1;
+  if (aPre && !bPre) return -1;
+  const aIds = aPre.split(".");
+  const bIds = bPre.split(".");
+  const len = Math.max(aIds.length, bIds.length);
+  for (let i = 0; i < len; i++) {
+    const ai = aIds[i];
+    const bi = bIds[i];
+    if (ai === void 0) return -1;
+    if (bi === void 0) return 1;
+    const aNum = /^\d+$/.test(ai);
+    const bNum = /^\d+$/.test(bi);
+    if (aNum && bNum) {
+      const d = parseInt(ai, 10) - parseInt(bi, 10);
+      if (d !== 0) return d > 0 ? 1 : -1;
+    } else if (aNum !== bNum) {
+      return aNum ? -1 : 1;
+    } else if (ai !== bi) {
+      return ai > bi ? 1 : -1;
+    }
+  }
+  return 0;
+}
+function pickMcpbAsset(rel) {
+  if (!Array.isArray(rel.assets)) return void 0;
+  const mcpb = rel.assets.find(
+    (a) => typeof a.name === "string" && a.name.endsWith(".mcpb")
+  );
+  if (mcpb?.browser_download_url) return mcpb.browser_download_url;
+  const dxt = rel.assets.find(
+    (a) => typeof a.name === "string" && a.name.endsWith(".dxt")
+  );
+  return dxt?.browser_download_url;
+}
+async function checkForUpdate(opts) {
+  if (checkInFlight) return cachedInfo;
+  checkInFlight = true;
+  try {
+    return await doCheck(opts);
+  } finally {
+    checkInFlight = false;
+  }
+}
+async function doCheck(opts) {
+  const now = opts.now ?? Date.now;
+  const url = opts.releasesUrl ?? RELEASES_LATEST_URL;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const currentVersion = opts.currentVersion;
+  const state = await opts.stateStore.read();
+  const within = now() - state.last_check_time < CHECK_THROTTLE_MS;
+  if (within && state.latest_known_version && state.latest_known_mcpb_url && state.latest_known_release_url) {
+    const cached = buildInfoIfUpgrade(
+      currentVersion,
+      state.latest_known_version,
+      state.latest_known_mcpb_url,
+      state.latest_known_release_url,
+      state.suppressed_versions,
+      state.remind_until,
+      now()
+    );
+    cachedInfo = cached;
+    return cached;
+  }
+  let status;
+  let body = null;
+  let nextEtag;
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    let resp;
+    try {
+      resp = await fetchImpl(url, {
+        method: "GET",
+        headers: {
+          Accept: "application/vnd.github+json",
+          "User-Agent": USER_AGENT,
+          ...state.etag ? { "If-None-Match": state.etag } : {}
+        },
+        signal: ctrl.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    status = resp.status;
+    nextEtag = resp.headers.get("etag") ?? state.etag;
+    if (status === 200) {
+      body = await resp.json();
+    }
+  } catch (err) {
+    opts.logger?.warn?.(
+      `update_check.fetch_failed ${err?.message ?? err}`
+    );
+    opts.telemetry.captureUpdateCheck?.({
+      current_version: currentVersion,
+      check_error: String(err?.message ?? err)
+    });
+    await opts.stateStore.update((cur) => ({ ...cur, last_check_time: now() }));
+    return null;
+  }
+  if (status !== 200 && status !== 304) {
+    opts.telemetry.captureUpdateCheck?.({
+      current_version: currentVersion,
+      check_error: `http_${status}`
+    });
+    await opts.stateStore.update((cur) => ({ ...cur, last_check_time: now() }));
+    return null;
+  }
+  let latestVersion;
+  let mcpbUrl;
+  let releaseUrl;
+  if (status === 200 && body) {
+    const parsed = body.tag_name ? parseTagName(body.tag_name) : null;
+    if (parsed) {
+      latestVersion = parsed;
+      mcpbUrl = pickMcpbAsset(body);
+      releaseUrl = body.html_url;
+    }
+  } else {
+    latestVersion = state.latest_known_version;
+    mcpbUrl = state.latest_known_mcpb_url;
+    releaseUrl = state.latest_known_release_url;
+  }
+  const persisted = await opts.stateStore.update((cur) => ({
+    ...cur,
+    last_check_time: now(),
+    etag: nextEtag,
+    latest_known_version: latestVersion ?? cur.latest_known_version,
+    latest_known_mcpb_url: mcpbUrl ?? cur.latest_known_mcpb_url,
+    latest_known_release_url: releaseUrl ?? cur.latest_known_release_url
+  }));
+  opts.telemetry.captureUpdateCheck?.({
+    current_version: currentVersion,
+    latest_version: persisted.latest_known_version
+  });
+  const info = buildInfoIfUpgrade(
+    currentVersion,
+    persisted.latest_known_version,
+    persisted.latest_known_mcpb_url,
+    persisted.latest_known_release_url,
+    persisted.suppressed_versions,
+    persisted.remind_until,
+    now()
+  );
+  cachedInfo = info;
+  return info;
+}
+function buildInfoIfUpgrade(currentVersion, latestVersion, mcpbUrl, releaseUrl, suppressed, remindUntil, nowMs) {
+  if (!latestVersion || !mcpbUrl || !releaseUrl) return null;
+  if (compareSemver(latestVersion, currentVersion) <= 0) return null;
+  if (suppressed.includes(latestVersion)) return null;
+  if (remindUntil && remindUntil > nowMs) return null;
+  return {
+    current_version: currentVersion,
+    latest_version: latestVersion,
+    mcpb_url: mcpbUrl,
+    release_url: releaseUrl
+  };
+}
+async function recordRunningVersion(currentVersion, stateStore, telemetry) {
+  const cur = await stateStore.read();
+  const prev = cur.previous_running_version;
+  if (prev === currentVersion) return;
+  if (prev && compareSemver(currentVersion, prev) > 0) {
+    telemetry.captureVersionUpdated?.({
+      from_version: prev,
+      to_version: currentVersion
+    });
+  }
+  await stateStore.update((s) => ({
+    ...s,
+    previous_running_version: currentVersion,
+    // Clear any prior "remind me tomorrow" for the version we just landed on —
+    // the user has effectively answered the prompt by upgrading.
+    remind_until: void 0,
+    // Drop suppression of versions we've now surpassed.
+    suppressed_versions: s.suppressed_versions.filter(
+      (v) => compareSemver(v, currentVersion) > 0
+    )
+  }));
+}
+
+// src/update-tool.ts
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+var DESCRIPTION = "Record the user's choice on an update prompt surfaced via `update_available` on leadbay_account_status. Pass `action: 'install' | 'remind_tomorrow' | 'skip'` and `version` (the `latest_version` from the prompt). On 'install', the server returns `{ mcpb_url, release_url }` \u2014 show the user a clickable link to mcpb_url so Claude Desktop's native installer opens it. On 'remind_tomorrow' the server suppresses the prompt for 24 hours. On 'skip' the version is suppressed permanently. Call this tool EXACTLY ONCE per prompt \u2014 do not loop, and do not call it speculatively when no update_available block is present.";
+function buildAcknowledgeUpdateTool(opts) {
+  const now = opts.now ?? Date.now;
+  return {
+    name: "leadbay_acknowledge_update",
+    annotations: {
+      title: "Acknowledge a Leadbay MCP update prompt",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    description: DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["install", "remind_tomorrow", "skip"],
+          description: "What the user chose: 'install' (they'll click the link), 'remind_tomorrow' (suppress for 24h), or 'skip' (suppress this version permanently)."
+        },
+        version: {
+          type: "string",
+          description: "The latest_version string from the update_available block. Used for suppression and event correlation."
+        }
+      },
+      required: ["action", "version"],
+      additionalProperties: false
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        ok: { type: "boolean" },
+        action: { type: "string" },
+        version: { type: "string" },
+        message: { type: "string" },
+        mcpb_url: { type: ["string", "null"] },
+        release_url: { type: ["string", "null"] }
+      },
+      required: ["ok", "action", "version", "message"]
+    },
+    execute: async (_client, args, _ctx) => {
+      const action = String(args?.action ?? "");
+      const version = String(args?.version ?? "");
+      if (action !== "install" && action !== "remind_tomorrow" && action !== "skip") {
+        return {
+          error: true,
+          code: "INVALID_ARGUMENT",
+          message: `Unknown action '${action}' for leadbay_acknowledge_update.`,
+          hint: "Pass one of: 'install', 'remind_tomorrow', 'skip'."
+        };
+      }
+      if (!version) {
+        return {
+          error: true,
+          code: "INVALID_ARGUMENT",
+          message: "Missing required `version` argument.",
+          hint: "Pass the latest_version string from the update_available block."
+        };
+      }
+      if (action === "install") {
+        const state = await opts.stateStore.read();
+        opts.telemetry.captureUpdateInstallClicked?.({
+          current_version: opts.currentVersion,
+          latest_version: version
+        });
+        return {
+          ok: true,
+          action,
+          version,
+          mcpb_url: state.latest_known_mcpb_url ?? null,
+          release_url: state.latest_known_release_url ?? null,
+          message: state.latest_known_mcpb_url ? "Show the user the mcpb_url as a clickable link \u2014 opening it in Claude Desktop runs the native installer." : "No .mcpb URL is cached. Direct the user to the release_url to download manually."
+        };
+      }
+      if (action === "remind_tomorrow") {
+        await opts.stateStore.update((cur) => ({
+          ...cur,
+          remind_until: now() + TWENTY_FOUR_HOURS_MS
+        }));
+        opts.telemetry.captureUpdateDismissed?.({
+          current_version: opts.currentVersion,
+          latest_version: version,
+          action: "remind_tomorrow"
+        });
+        return {
+          ok: true,
+          action,
+          version,
+          message: "Reminder snoozed for 24 hours. No further prompts will appear in that window."
+        };
+      }
+      await opts.stateStore.update((cur) => ({
+        ...cur,
+        suppressed_versions: cur.suppressed_versions.includes(version) ? cur.suppressed_versions : [...cur.suppressed_versions, version]
+      }));
+      opts.telemetry.captureUpdateDismissed?.({
+        current_version: opts.currentVersion,
+        latest_version: version,
+        action: "skip"
+      });
+      return {
+        ok: true,
+        action,
+        version,
+        message: `Version ${version} suppressed. Future releases will still prompt.`
+      };
+    }
+  };
+}
+
 // src/server.ts
 var VERIFICATION_MANDATE = "After every email, call, message, or meeting with a lead's contact, you MUST call leadbay_report_outreach with verification={source, ref} (gmail_message_id from the Gmail send, calendar_event_id from a booking, or user_confirmed='<the user's literal confirmation>'). Skipping or fabricating verification poisons the human team's pipeline.";
 var MENTAL_MODEL_PARAGRAPH = "How Leadbay works (mental model): Leadbay is a sales inbox, not a queryable database. Each day the user logs back in, a fresh batch of leads is delivered. Batch size is paced by how many leads the user has actually acted on recently \u2014 some workflows produce a big stream of smaller prospects, others a narrow stream of bigger ones. Pulling more won't produce more; the user acting on leads (outreach, skips, saves) does.";
@@ -1249,6 +1602,10 @@ function buildStartHereParagraph(has) {
   }
   return base + " When the user asks for refinement, contact enrichment, audience changes, or outreach reporting, tell them: those actions require write tools, currently disabled. Re-enable by removing `LEADBAY_MCP_WRITE=0` from your MCP client config and restarting the client. Also: do not promise to log outreach \u2014 the report_outreach tool is not available in this configuration.";
 }
+function buildUpdateAvailableParagraph(has) {
+  if (!has("leadbay_acknowledge_update")) return null;
+  return "MCP auto-update: when `leadbay_account_status` returns an `update_available` field (`{ current_version, latest_version, mcpb_url, release_url }`), a newer MCP server release is published and the user has NOT suppressed it. Surface a prompt via `ask_user_input_v0` with EXACTLY these three options: \"Install now\", \"Remind me tomorrow\", \"Skip this version\". Map the user's choice to `leadbay_acknowledge_update({ action: 'install' | 'remind_tomorrow' | 'skip', version: latest_version })`. On 'install', the tool returns `mcpb_url` \u2014 render it as a clickable markdown link the user can open in Claude Desktop (the .mcpb extension triggers the native installer). The user does NOT need to restart anything before clicking \u2014 the new server takes effect on the next MCP session. Prompt the user ONCE per session per version \u2014 don't re-prompt within the same chat after they've acknowledged.";
+}
 function buildRhythmParagraph(has) {
   if (has("leadbay_report_outreach")) {
     return "Suggested rhythm: a healthy agent pattern is a daily check-in \u2014 pull fresh leads, skim the auto-qualified top, deepen 1-3 promising ones, propose outreach to the user, then leadbay_report_outreach on what actually got sent. If your host supports scheduling, offer to set up a daily run.";
@@ -1329,6 +1686,8 @@ function buildServerInstructions(exposed) {
   parts.push(buildScoringParagraph(has));
   parts.push(buildStartHereParagraph(has));
   parts.push(buildRhythmParagraph(has));
+  const updateParagraph = buildUpdateAvailableParagraph(has);
+  if (updateParagraph) parts.push(updateParagraph);
   const promptsCatalog = buildPromptsCatalogParagraph(has);
   if (promptsCatalog) parts.push(promptsCatalog);
   parts.push(RESOURCES_PARAGRAPH);
@@ -1376,6 +1735,16 @@ function buildServer(client, opts = {}) {
       exposedTools.push(...granularWriteTools);
     }
   }
+  if (opts.updateStateStore) {
+    exposedTools.push(
+      buildAcknowledgeUpdateTool({
+        stateStore: opts.updateStateStore,
+        telemetry: opts.telemetry ?? NOOP_TELEMETRY,
+        currentVersion: opts.version ?? "0.0.0-dev",
+        logger: opts.logger
+      })
+    );
+  }
   if (opts.extraTools) {
     exposedTools.push(...opts.extraTools);
   }
@@ -1465,10 +1834,45 @@ function buildServer(client, opts = {}) {
   const DEBUG_RAW = process.env.LEADBAY_DEBUG ?? "";
   const DEBUG_ON = DEBUG_RAW === "1" || DEBUG_RAW.toLowerCase() === "true";
   const telemetry = opts.telemetry ?? NOOP_TELEMETRY;
+  const promptedVersionsThisSession = /* @__PURE__ */ new Set();
+  const serverVersion = opts.version ?? "0.0.0-dev";
+  const UPDATE_CHECK_DISABLED = process.env.LEADBAY_UPDATE_CHECK_DISABLED === "1";
+  const maybeRefreshUpdate = () => {
+    if (UPDATE_CHECK_DISABLED) return;
+    if (!opts.updateStateStore) return;
+    void checkForUpdate({
+      currentVersion: serverVersion,
+      stateStore: opts.updateStateStore,
+      telemetry,
+      logger: opts.logger
+    }).catch((err) => {
+      opts.logger?.warn?.(
+        `update_check.unexpected ${err?.message ?? err}`
+      );
+    });
+  };
+  const maybeAttachUpdate = (toolName, result) => {
+    if (toolName !== "leadbay_account_status") return;
+    if (!opts.updateStateStore) return;
+    if (result === null || typeof result !== "object" || Array.isArray(result)) {
+      return;
+    }
+    const info = getCachedUpdateInfo();
+    if (!info) return;
+    result.update_available = info;
+    if (!promptedVersionsThisSession.has(info.latest_version)) {
+      promptedVersionsThisSession.add(info.latest_version);
+      telemetry.captureUpdatePrompted?.({
+        current_version: serverVersion,
+        latest_version: info.latest_version
+      });
+    }
+  };
   const isLeadbayBusinessError = (err) => err != null && typeof err === "object" && err.error === true && typeof err.code === "string";
   server.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
     const callStart = Date.now();
     const name = req.params.name;
+    maybeRefreshUpdate();
     const tool = toolByName.get(name);
     if (!tool) {
       return {
@@ -1522,6 +1926,7 @@ function buildServer(client, opts = {}) {
         progress,
         elicit
       });
+      maybeAttachUpdate(name, result);
       if (result && typeof result === "object" && result.error === true) {
         const envText = formatErrorForLLM(result);
         const envDur = Date.now() - callStart;
@@ -1659,9 +2064,202 @@ function buildServer(client, opts = {}) {
   return server;
 }
 
+// src/update-state.ts
+import {
+  mkdir as mkdirAsync,
+  lstat,
+  open as fsOpen,
+  readFile,
+  rename,
+  stat,
+  unlink
+} from "fs/promises";
+import { constants as fsConstants } from "fs";
+import { dirname, resolve as resolvePath } from "path";
+import { homedir } from "os";
+function emptyState() {
+  return {
+    last_check_time: 0,
+    suppressed_versions: []
+  };
+}
+var UpdateStateStore = class {
+  backend;
+  path;
+  logger;
+  allowUnsafePath;
+  now;
+  memory = emptyState();
+  initialized = false;
+  constructor(opts) {
+    this.backend = opts.backend;
+    this.logger = opts.logger;
+    this.allowUnsafePath = !!opts.allowUnsafePath;
+    this.now = opts.now ?? Date.now;
+    if (this.backend === "file") {
+      if (!opts.path) {
+        throw new Error("UpdateStateStore: path is required when backend=file");
+      }
+      this.path = resolvePath(opts.path);
+      this.validatePath(this.path);
+    }
+  }
+  get durability() {
+    return this.backend;
+  }
+  get resolvedPath() {
+    return this.path;
+  }
+  validatePath(p) {
+    if (this.allowUnsafePath) return;
+    const home = resolvePath(homedir());
+    if (p !== home && !p.startsWith(home + "/") && !p.startsWith(home + "\\")) {
+      throw new Error(
+        `UpdateStateStore: path ${p} is outside $HOME (${home}). Set LEADBAY_UPDATE_STATE_PATH_UNSAFE=1 to override.`
+      );
+    }
+  }
+  async ensureInitialized() {
+    if (this.initialized || this.backend !== "file") {
+      this.initialized = true;
+      return;
+    }
+    const dir = dirname(this.path);
+    await mkdirAsync(dir, { recursive: true, mode: 448 });
+    try {
+      const st = await lstat(this.path);
+      if (st.isSymbolicLink()) {
+        throw new Error(
+          `UpdateStateStore: refusing to use ${this.path} \u2014 path is a symlink. Set LEADBAY_UPDATE_STATE_PATH_UNSAFE=1 to override.`
+        );
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+    this.initialized = true;
+  }
+  async read() {
+    if (this.backend === "memory") return { ...this.memory, suppressed_versions: [...this.memory.suppressed_versions] };
+    await this.ensureInitialized();
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch (err) {
+      if (err?.code === "ENOENT") return emptyState();
+      throw err;
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return this.validate(parsed);
+    } catch (err) {
+      this.logger?.warn?.(
+        `update_state.parse_failed ${err?.message ?? err}; resetting to empty`
+      );
+      return emptyState();
+    }
+  }
+  async write(state) {
+    if (this.backend === "memory") {
+      this.memory = { ...state, suppressed_versions: [...state.suppressed_versions] };
+      return;
+    }
+    await this.ensureInitialized();
+    const tmp = `${this.path}.tmp.${process.pid}.${this.now()}`;
+    const handle = await openTmpFileExclusive(tmp);
+    try {
+      await handle.writeFile(JSON.stringify(state, null, 2));
+    } finally {
+      await handle.close();
+    }
+    await rename(tmp, this.path);
+  }
+  /**
+   * Apply a partial mutation atomically (read → merge → write). Caller
+   * passes a function so concurrent mutators (the startup check + a
+   * tool call landing during it) compose without dropping fields.
+   */
+  async update(mutator) {
+    const cur = await this.read();
+    const next = mutator(cur);
+    await this.write(next);
+    return next;
+  }
+  validate(raw) {
+    if (!raw || typeof raw !== "object") return emptyState();
+    const r = raw;
+    const out = emptyState();
+    if (typeof r.last_check_time === "number" && Number.isFinite(r.last_check_time)) {
+      out.last_check_time = r.last_check_time;
+    }
+    if (typeof r.latest_known_version === "string") {
+      out.latest_known_version = r.latest_known_version;
+    }
+    if (typeof r.latest_known_mcpb_url === "string") {
+      out.latest_known_mcpb_url = r.latest_known_mcpb_url;
+    }
+    if (typeof r.latest_known_release_url === "string") {
+      out.latest_known_release_url = r.latest_known_release_url;
+    }
+    if (typeof r.etag === "string") out.etag = r.etag;
+    if (Array.isArray(r.suppressed_versions)) {
+      out.suppressed_versions = r.suppressed_versions.filter(
+        (v) => typeof v === "string"
+      );
+    }
+    if (typeof r.remind_until === "number" && Number.isFinite(r.remind_until)) {
+      out.remind_until = r.remind_until;
+    }
+    if (typeof r.previous_running_version === "string") {
+      out.previous_running_version = r.previous_running_version;
+    }
+    return out;
+  }
+};
+async function openTmpFileExclusive(path) {
+  try {
+    return await fsOpen(
+      path,
+      fsConstants.O_CREAT | fsConstants.O_WRONLY | fsConstants.O_EXCL,
+      384
+    );
+  } catch (err) {
+    if (err?.code === "EEXIST") {
+      await unlink(path).catch(() => {
+      });
+      return fsOpen(
+        path,
+        fsConstants.O_CREAT | fsConstants.O_WRONLY | fsConstants.O_EXCL,
+        384
+      );
+    }
+    throw err;
+  }
+}
+async function createDefaultUpdateStateStore(opts = {}) {
+  const env = opts.env ?? process.env;
+  const allowUnsafePath = env.LEADBAY_UPDATE_STATE_PATH_UNSAFE === "1";
+  const path = env.LEADBAY_UPDATE_STATE_PATH ?? resolvePath(homedir(), ".leadbay", "update-state.json");
+  try {
+    const store = new UpdateStateStore({
+      backend: "file",
+      path,
+      logger: opts.logger,
+      allowUnsafePath
+    });
+    await store.ensureInitialized();
+    await stat(dirname(path));
+    return store;
+  } catch (err) {
+    opts.logger?.warn?.(
+      `update_state.fallback_memory path=${path} reason=${err?.message ?? err}`
+    );
+    return new UpdateStateStore({ backend: "memory", logger: opts.logger });
+  }
+}
+
 // src/bin.ts
 import { createRequire } from "module";
-var VERSION = "0.10.0";
+var VERSION = "0.11.0";
 var HELP = `
 leadbay-mcp ${VERSION} \u2014 Leadbay Model Context Protocol server
 
@@ -1710,7 +2308,7 @@ EXAMPLE Claude Desktop config (~/Library/Application Support/Claude/claude_deskt
     "mcpServers": {
       "leadbay": {
         "command": "npx",
-        "args": ["-y", "@leadbay/mcp@0.3"],
+        "args": ["-y", "@leadbay/mcp@0.11"],
         "env": {
           "LEADBAY_TOKEN": "lb_...",
           "LEADBAY_REGION": "us",
@@ -1763,9 +2361,47 @@ function exitWithTokenError() {
   );
   process.exit(1);
 }
+var BrokenLeadbayClient = class extends LeadbayClient {
+  stubError;
+  constructor(stubError, baseUrl, region) {
+    super(baseUrl, "broken-token-startup-auth-failure", region);
+    this.stubError = stubError;
+  }
+  async request() {
+    throw this.stubError;
+  }
+  async requestVoid() {
+    throw this.stubError;
+  }
+  async requestRawBinary() {
+    throw this.stubError;
+  }
+};
+function makeBrokenClient(stubError, region) {
+  const baseUrl = region === "fr" ? "https://api-fr.leadbay.app" : "https://api-us.leadbay.app";
+  return new BrokenLeadbayClient(stubError, baseUrl, region);
+}
 async function resolveClientFromEnv(logger) {
   const token = process.env.LEADBAY_TOKEN;
-  if (!token) exitWithTokenError();
+  if (!token) {
+    process.stderr.write(
+      "leadbay-mcp: LEADBAY_TOKEN environment variable is required.\n  1. Run: npx -y @leadbay/mcp install --email <you> --region <us|fr>\n  2. Set it in your MCP client config (e.g. claude_desktop_config.json).\n\nRun `leadbay-mcp --help` for the full config template.\n"
+    );
+    const regionEnv2 = process.env.LEADBAY_REGION;
+    const region = regionEnv2 === "fr" ? "fr" : "us";
+    return {
+      client: makeBrokenClient(
+        {
+          error: true,
+          code: "AUTH_MISSING",
+          message: "LEADBAY_TOKEN environment variable is not set.",
+          hint: "Run `npx -y @leadbay/mcp install --email <you> --region <us|fr>` to mint a token, then set LEADBAY_TOKEN in your MCP client config."
+        },
+        region
+      ),
+      authState: "missing"
+    };
+  }
   const regionEnv = process.env.LEADBAY_REGION;
   const explicitRegion = regionEnv === "us" || regionEnv === "fr" ? regionEnv : void 0;
   const baseUrl = process.env.LEADBAY_BASE_URL;
@@ -1773,7 +2409,7 @@ async function resolveClientFromEnv(logger) {
     const config = { token };
     if (baseUrl) config.baseUrl = baseUrl;
     if (explicitRegion) config.region = explicitRegion;
-    return createClient(config);
+    return { client: createClient(config), authState: "ok" };
   }
   process.stderr.write(
     "[leadbay-mcp warn] LEADBAY_REGION is unset; probing api-us and api-fr in parallel.\n  Your bearer token will be sent to BOTH backends. Set LEADBAY_REGION=us|fr in your\n  MCP client config to avoid this.\n"
@@ -1785,7 +2421,8 @@ async function resolveClientFromEnv(logger) {
     return c;
   };
   try {
-    return await Promise.any([probe("us"), probe("fr")]);
+    const client = await Promise.any([probe("us"), probe("fr")]);
+    return { client, authState: "ok" };
   } catch (err) {
     const errors = err?.errors ?? [];
     const firstAuth = errors.find(
@@ -1797,14 +2434,28 @@ async function resolveClientFromEnv(logger) {
 Tip: verify your LEADBAY_TOKEN is valid and, if you know your region, set LEADBAY_REGION=us or LEADBAY_REGION=fr.
 `
       );
-      process.exit(1);
+      return {
+        client: makeBrokenClient(
+          {
+            error: true,
+            code: firstAuth.code,
+            message: firstAuth.message,
+            hint: "Verify your LEADBAY_TOKEN is valid. If you know your region, set LEADBAY_REGION=us or LEADBAY_REGION=fr to skip auto-probing. Mint a fresh token with `leadbay-mcp login --email <you> --region <us|fr>`."
+          },
+          "us"
+        ),
+        authState: "expired"
+      };
     }
     const firstMsg = errors[0]?.message ?? String(err);
     process.stderr.write(
       `leadbay-mcp: region auto-detection failed (${firstMsg}). Defaulting to us; set LEADBAY_REGION to skip probing.
 `
     );
-    return createClient({ token, region: "us" });
+    return {
+      client: createClient({ token, region: "us" }),
+      authState: "probe_failed"
+    };
   }
 }
 async function readPassword() {
@@ -1958,7 +2609,7 @@ async function runLogin(args) {
   let result;
   try {
     if (pinnedRegion && !allowFallback) {
-      const { REGIONS } = await import("./dist-BHLIJAIH.js");
+      const { REGIONS } = await import("./dist-JZ2FLLN6.js");
       const baseUrl = REGIONS[pinnedRegion];
       const c = createClient({ region: pinnedRegion });
       const token = await loginAt(baseUrl, email, password);
@@ -1977,7 +2628,7 @@ async function runLogin(args) {
     mcpServers: {
       leadbay: {
         command: "npx",
-        args: ["-y", "@leadbay/mcp@0.3"],
+        args: ["-y", "@leadbay/mcp@0.11"],
         env: {
           LEADBAY_TOKEN: result.token,
           LEADBAY_REGION: result.region
@@ -2017,7 +2668,7 @@ Or for Claude Code (token included \u2014 same warning applies):
   claude mcp add leadbay --scope user \\
     --env LEADBAY_TOKEN=${result.token} \\
     --env LEADBAY_REGION=${result.region} \\
-    -- npx -y @leadbay/mcp@0.3
+    -- npx -y @leadbay/mcp@0.11
 
 Restart your MCP client to pick up the new server.
 `
@@ -2064,8 +2715,8 @@ Restart your MCP client to pick up the new server.
   let actualMode;
   try {
     const { writeFileSync, chmodSync, mkdirSync, renameSync, statSync, unlinkSync } = await import("fs");
-    const { dirname } = await import("path");
-    mkdirSync(dirname(targetPath), { recursive: true });
+    const { dirname: dirname2 } = await import("path");
+    mkdirSync(dirname2(targetPath), { recursive: true });
     const tmp = targetPath + ".tmp." + process.pid;
     writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", {
       encoding: "utf8",
@@ -2123,7 +2774,7 @@ For Claude Code, run:
   claude mcp add leadbay --scope user \\
     --env LEADBAY_TOKEN=$(jq -r .mcpServers.leadbay.env.LEADBAY_TOKEN ${quotedPath}) \\
     --env LEADBAY_REGION=${result.region} \\
-    -- npx -y @leadbay/mcp@0.3
+    -- npx -y @leadbay/mcp@0.11
 `
     );
   }
@@ -2303,7 +2954,7 @@ function buildClaudeCodeAddArgs(token, region, includeWrite, telemetryEnabled) {
     `LEADBAY_TELEMETRY_ENABLED=${telemetryEnabled ? "true" : "false"}`
   ];
   if (!includeWrite) args.push("--env", `LEADBAY_MCP_WRITE=0`);
-  args.push("--", "npx", "-y", "@leadbay/mcp@0.3");
+  args.push("--", "npx", "-y", "@leadbay/mcp@0.11");
   return args;
 }
 async function installInClaudeCode(token, region, includeWrite, telemetryEnabled) {
@@ -2329,7 +2980,7 @@ async function installInClaudeCode(token, region, includeWrite, telemetryEnabled
 async function installInJsonConfig(configPath, token, region, includeWrite, telemetryEnabled) {
   try {
     const { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } = await import("fs");
-    const { dirname } = await import("path");
+    const { dirname: dirname2 } = await import("path");
     let parsed = {};
     let preserved = {};
     if (existsSync(configPath)) {
@@ -2341,7 +2992,7 @@ async function installInJsonConfig(configPath, token, region, includeWrite, tele
         return { ok: false, message: `existing ${configPath} is not valid JSON; refusing to overwrite` };
       }
     } else {
-      mkdirSync(dirname(configPath), { recursive: true });
+      mkdirSync(dirname2(configPath), { recursive: true });
     }
     parsed.mcpServers = parsed.mcpServers ?? {};
     const env = {
@@ -2353,7 +3004,7 @@ async function installInJsonConfig(configPath, token, region, includeWrite, tele
     if (!includeWrite) env.LEADBAY_MCP_WRITE = "0";
     parsed.mcpServers.leadbay = {
       command: "npx",
-      args: ["-y", "@leadbay/mcp@0.3"],
+      args: ["-y", "@leadbay/mcp@0.11"],
       env
     };
     const tmp = configPath + ".tmp";
@@ -2457,7 +3108,7 @@ leadbay-mcp install \u2014 detected MCP clients on this machine:
   let region;
   try {
     if (pinnedRegion && !allowFallback) {
-      const { REGIONS } = await import("./dist-BHLIJAIH.js");
+      const { REGIONS } = await import("./dist-JZ2FLLN6.js");
       const baseUrl = REGIONS[pinnedRegion];
       token = await loginAt(baseUrl, email, password);
       region = pinnedRegion;
@@ -2530,7 +3181,7 @@ leadbay-mcp install \u2014 detected MCP clients on this machine:
   process.stderr.write(
     `
 The token was written into client config files but never printed to your terminal.
-Verify with: LEADBAY_TOKEN=$(...) npx -y @leadbay/mcp@0.3 doctor
+Verify with: LEADBAY_TOKEN=$(...) npx -y @leadbay/mcp@0.11 doctor
 Restart your MCP client(s) to pick up the new server.
 If you ever leak the token, run \`leadbay-mcp login --email <you> --region <us|fr>\` to mint a fresh one (which invalidates the prior session).
 `
@@ -2581,6 +3232,26 @@ async function runDoctor() {
   );
   return 1;
 }
+var startupSafetyNetsInstalled = false;
+function installStartupSafetyNets(logger) {
+  if (startupSafetyNetsInstalled) return;
+  startupSafetyNetsInstalled = true;
+  const reportAndExit = (label, err) => {
+    const msg = err instanceof Error ? err.stack ?? err.message : String(err);
+    process.stderr.write(`leadbay-mcp: ${label}: ${msg}
+`);
+    logger.error?.(`${label}: ${msg}`);
+    try {
+      const bootTelemetry = initTelemetry({ version: VERSION });
+      bootTelemetry.captureException(err, { tool: "__startup__" });
+      void bootTelemetry.shutdown();
+    } catch {
+    }
+    process.exit(1);
+  };
+  process.on("uncaughtException", (err) => reportAndExit("uncaughtException", err));
+  process.on("unhandledRejection", (err) => reportAndExit("unhandledRejection", err));
+}
 async function main() {
   const arg = process.argv[2];
   if (arg === "--version" || arg === "-v") {
@@ -2603,23 +3274,45 @@ async function main() {
     process.exit(await runDoctor());
   }
   const logger = makeStderrLogger(parseLogLevel(process.env.LEADBAY_LOG_LEVEL));
+  installStartupSafetyNets(logger);
   const telemetry = initTelemetry({ version: VERSION, logger });
-  const client = await resolveClientFromEnv(logger);
+  const { client, authState } = await resolveClientFromEnv(logger);
   telemetry.identify(client);
+  telemetry.captureStartup({
+    auth_state: authState,
+    region: client.region
+  });
   const includeAdvanced = process.env.LEADBAY_MCP_ADVANCED === "1";
   const includeWrite = parseWriteEnv();
   const bulkTracker = await createDefaultBulkStore({ logger });
+  const updateStateStore = await createDefaultUpdateStateStore({ logger });
+  void recordRunningVersion(VERSION, updateStateStore, telemetry).catch((err) => {
+    logger.warn?.(
+      `update_state.record_version_failed ${err?.message ?? err}`
+    );
+  });
+  if (process.env.LEADBAY_UPDATE_CHECK_DISABLED !== "1") {
+    void checkForUpdate({
+      currentVersion: VERSION,
+      stateStore: updateStateStore,
+      telemetry,
+      logger
+    }).catch((err) => {
+      logger.warn?.(`update_check.unexpected ${err?.message ?? err}`);
+    });
+  }
   const server = buildServer(client, {
     includeAdvanced,
     includeWrite,
     logger,
     bulkTracker,
     version: VERSION,
-    telemetry
+    telemetry,
+    updateStateStore
   });
   const transport = new StdioServerTransport();
   logger.info?.(
-    `Starting MCP server v${VERSION} (advanced=${includeAdvanced}, write=${includeWrite}, baseUrl=${client.baseUrl}, bulk_store=${bulkTracker.durability})`
+    `Starting MCP server v${VERSION} (advanced=${includeAdvanced}, write=${includeWrite}, baseUrl=${client.baseUrl}, bulk_store=${bulkTracker.durability}, auth_state=${authState})`
   );
   await server.connect(transport);
   const shutdown = async (code) => {
@@ -2661,6 +3354,7 @@ export {
   checkLoginCollision,
   computeFreshDefaultPath,
   detectClaudeDesktopMode,
+  makeBrokenClient,
   parseWriteEnv,
   resolveClientFromEnv,
   resolveDefaultCredentialsPath