@trylighthouse/mcp-server 0.1.101

package/build/server.js

@@ -0,0 +1,2903 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { LighthouseAPI } from "./api.js";
+import { leanDiscovery } from "./leanDiscovery.js";
+function text(data) {
+    const failed = data != null && typeof data === "object" && data.error != null;
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }], ...(failed ? { isError: true } : {}) };
+}
+function err(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+function profileSection(res, keys) {
+    if (res == null || typeof res !== "object")
+        return res;
+    const envelope = res;
+    if (envelope.error != null || envelope.data == null || typeof envelope.data !== "object" || Array.isArray(envelope.data)) {
+        return res;
+    }
+    const data = envelope.data;
+    const section = { id: data.id ?? null, name: data.name ?? null };
+    for (const key of keys)
+        section[key] = data[key] ?? null;
+    return { ...envelope, data: section };
+}
+const TRANSCRIPT_WINDOW_CHARS = 40_000;
+export function createServer(apiKey) {
+    const api = new LighthouseAPI(apiKey);
+    const server = new McpServer({
+        name: "lighthouse",
+        version: "0.1.101",
+    });
+    const originalRegister = server.registerTool.bind(server);
+    server.registerTool = (name, schemaOrConfig, handler) => {
+        const wrappedHandler = async (...args) => {
+            api.setCurrentTool(name);
+            try {
+                return await handler(...args);
+            }
+            finally {
+                api.setCurrentTool(null);
+            }
+        };
+        return originalRegister(name, schemaOrConfig, wrappedHandler);
+    };
+    const CRM_FILTER_DESCRIPTION = "CRM filter object. Format: " +
+        '{"operator":"AND","conditions":[{"field":"<key>","operator":"<op>","value":<val>}],"groups":[]}. ' +
+        "IMPORTANT: First call lighthouse_crm_get_attributes to discover available field keys and types. " +
+        "Operators by field type, " +
+        "text/url: contains, not_contains, starts_with, ends_with, eq, neq, empty, not_empty; " +
+        "number/currency/rating/percentage: gt, gte, lt, lte, eq, neq, empty, not_empty; " +
+        "growth (headcount_growth on companies: the linked global profile's headcount change over 1m / 3m / 6m / 1y): gt, gte, lt, lte, eq, neq over ONE window with the value {\"timeframe\":\"1m\"|\"3m\"|\"6m\"|\"1y\",\"value\":<percent number>} (timeframe defaults to 3m; a bare number means the default window; an unknown window is refused), and empty / not_empty with no value (no window has data / at least one does); " +
+        "duration (time_in_stage on deals, time_in_status on tasks, and every time_in_<status field> twin that lighthouse_crm_get_attributes lists with a source_field: how long the record has held its current status): gt, gte, lt, lte, eq, neq over a whole number of DAYS (the value is a bare number such as 30, never an object; anything else is refused), and empty / not_empty with no value (the status is empty / set); " +
+        "date/datetimez: before, after, on, empty, not_empty; " +
+        "note (the notes field of companies, people, deals and custom object records: the notes linked to the record, never a body): eq (has a note matching), neq (has no note matching) with an object value whose keys are all optional and combined on ONE note: {\"title\":\"text it contains\",\"created_by\":[\"<teammate id from lighthouse_workspace_list_users>\"],\"since\":\"YYYY-MM-DD or a rolling period such as 30 days\",\"until\":\"...\",\"tags\":[\"<note tag permalink>\"],\"type\":\"standard\"|\"meeting\"} (an unknown key or a bad value is refused; with no refinement use not_empty), and empty / not_empty with no value (no note at all / at least one); " +
+        "select/status/user: contains_any, not_contains_any, empty, not_empty; " +
+        "multi_select/category/multi_user/multi_record/signal_select: contains_any, not_contains_any, contains_all, empty, not_empty; " +
+        "record: contains_any, not_contains_any, empty, not_empty; " +
+        "investors (a company's investors, a read-only multi_record of the GLOBAL DATABASE's companies and people): contains_any, not_contains_any, contains_all, empty, not_empty; the value is a list of investor ids from lighthouse_discovery_search_entities with record_type 'investor', never CRM record ids; " +
+        "experience / education (a person's work history and schools, read-only multi_records of the GLOBAL DATABASE's companies and schools): contains_any, not_contains_any, contains_all, empty, not_empty; the value is a list of ids from lighthouse_discovery_search_entities with record_type 'company' (record_type 'school' for education), never CRM record ids; " +
+        "domain/email/phone: contains_any, not_contains_any, contains_all, empty, not_empty; " +
+        "list_entries (the record's list memberships; the value is an array of list ids from lighthouse_crm_list_lists, and the list's record_type must be this record type): contains_any, not_contains_any, contains_all, empty, not_empty (empty = in no list, not_empty = in at least one list; both take no value). A question about the records IN a list with further conditions or an order (\"companies in list X created this month, newest first\") is ONE call: either lighthouse_crm_get_list_records with the same filters and sort, or this search with a list_entries contains_any condition on that list's id beside the other conditions; never read the whole list and narrow it by hand; " +
+        "checkbox: eq (value is true or false); " +
+        "interaction (first/last email & linkedin interaction, overall interaction-with): eq, neq, empty, not_empty; " +
+        "interaction-type (first/last interaction type): contains_any, not_contains_any, empty, not_empty. " +
+        "Value formats: text ops → string; number ops → number (a rating field's value is an integer 1-5, or null when unrated); " +
+        "contains_any/not_contains_any/contains_all → array of values; " +
+        "empty/not_empty → omit value; date ops → ISO date string \"YYYY-MM-DD\" or a rolling token resolved against the current time on every run: \"7 days\" or \"3 months ago\" = that period back (bare token means ago), \"2 weeks from now\" = that period forward (e.g. next_meeting_date before \"60 days from now\" = within the next 60 days). " +
+        "interaction eq/neq → {\"members\":[teammateUserId,...],\"directions\":[\"outbound\"|\"inbound\"|\"none\"]} " +
+        "(members OR-set of teammate user ids, directions OR-set, the two ANDed; meeting-based interactions have no member/direction so a direction/member filter excludes them; for companies a match means at least one associated person has such a touchpoint); " +
+        "interaction-type contains_any → array subset of [\"email\",\"linkedin\",\"meeting\"]; " +
+        "interaction date fields before/after/on → ISO date or a rolling token (\"60 days\", \"60 days from now\"), empty/not_empty → omit value. " +
+        "Linked-record fields filter via dotted paths <relation>.<field> (e.g. associated_people.emails on a company, associated_companies.name on a person; custom record-link fields and two-level paths like associated_deals.associated_people.emails work too) using the leaf field type's operators. Dotted paths work on company, person, deal and custom object records (a custom object's own record-link fields are its relations); on tasks and notes a dotted condition is ignored, so never use dotted fields there. " +
+        "On a dotted path every operator quantifies across ALL linked records: positive operators (contains, eq, contains_any, contains_all, the date and number comparisons, not_empty) match when at least one linked record matches; negative operators (neq, not_contains, not_contains_any, empty) match when NO linked record matches, INCLUDING records with no linked records at all, so not_contains_any with every option listed returns the same records as empty. " +
+        "semantic_search (people and companies ONLY; a FILTER, not an attribute: lighthouse_crm_get_attributes never lists it and no record carries it): operator matches, value {\"vector\":\"[...]\",\"min_similarity\"?:0 to 0.99}. It matches each record's linked global profile against a READY embedding. This API does NOT build embeddings from text: a {\"text\":...} value is refused with a 400 that says so, and you must never write a vector yourself. The vector comes from the app: a saved view's filters (lighthouse_crm_get_view returns them with the vector) or a condition the user copied with Copy for API in the filter builder. Reuse such a condition VERBATIM, at any depth of the tree and on a linked path (associated_companies.semantic_search on a person = people whose companies match the description, associated_people.semantic_search on a company). With no sort the page is ranked by similarity; only records linked to the global database can match. When the user wants a description-based search of the CRM and no saved view or copied condition carries a vector, say so and offer the attribute filters, or lighthouse_discovery_semantic_search_companies / _people for the global database (NOT the CRM). " +
+        "Dotted linked interaction filters, e.g. {\"field\":\"associated_companies.last_email_interaction\",\"operator\":\"eq\",\"value\":{\"members\":[\"<id>\"],\"directions\":[\"outbound\"]}}; dotted interaction keys support eq, neq, empty and not_empty. " +
+        "The `operator` of a block (the top level OR any group) is \"AND\" or \"OR\" and joins that block's conditions AND its nested groups: \"AND\" = every one must match, \"OR\" = at least one matches. Set the top-level operator to \"OR\" to OR the top-level conditions, or nest a group to mix logic like (A OR B) AND C. " +
+        'Nested-group example for "(domain contains acme OR name contains acme) AND created after 2025-01-01": ' +
+        '{"operator":"AND","conditions":[{"field":"created_at","operator":"after","value":"2025-01-01"}],"groups":[{"operator":"OR","conditions":[{"field":"domain","operator":"contains_any","value":["acme"]},{"field":"name","operator":"contains","value":"acme"}],"groups":[]}]} ' +
+        "(field keys above are illustrative, use the real keys from lighthouse_crm_get_attributes). " +
+        "Dates have NO range operator, express a window as two conditions (after <start> AND before <end>) in an AND group, computing the bounds from today's date. " +
+        "Use the EXACT field keys and option values returned by lighthouse_crm_get_attributes / lighthouse_crm_list_options, never abbreviate or invent them, the chosen values for a select/multi_select condition MUST be a subset of that field's options. If a requested concept has no matching field or option (e.g. a 'competitor'/'portfolio' status that no field actually holds), TELL THE USER rather than dropping the clause or mapping it onto an unrelated field. " +
+        "Do NOT use discovery field keys here, CRM fields come from lighthouse_crm_get_attributes. " +
+        "RESPONSE VALIDATION META: this search NEVER fails on a bad filter; instead the response carries, alongside `records`/`total`, three arrays you MUST inspect (collected recursively across nested groups): " +
+        "`ignored_filter_fields` (field keys not recognized; that condition was dropped), " +
+        "`invalid_operators` ([{field, operator}] where the operator is not valid for that field's type; that condition was dropped), and " +
+        "`invalid_logical_operators` ([{operator}] where a group's join was not AND/OR; treated as AND). " +
+        "If ANY are non-empty, part of your filter did NOT apply (results are broader/narrower than intended): fix the offending field/operator and retry, or tell the user which clauses could not be applied. A `warnings` array summarizes the same in plain text.";
+    const CRM_SORT_DESCRIPTION = 'CRM sort array. Format: [{"field":"<key>","direction":"asc"|"desc"}]. ' +
+        "Multiple entries sort by the first, then tie-break by the next. " +
+        "NOT every field is sortable. A field is sortable ONLY when its type (the `data_type` returned by lighthouse_crm_get_attributes) is one of: " +
+        "text, url, number, currency, percentage, rating, date, datetime, datetimez, select, status, user, checkbox, " +
+        "record, record_company_name, record_person_name, record_deal_name, growth, note, duration. " +
+        "growth (headcount_growth) sorts by ONE window: add \"timeframe\":\"1m\"|\"3m\"|\"6m\"|\"1y\" to the sort item ({\"field\":\"headcount_growth\",\"direction\":\"desc\",\"timeframe\":\"6m\"}; 3m when omitted; an unknown window comes back in invalid_sort_fields). " +
+        "note (the notes field) orders by the newest note's date, records without notes last. " +
+        "duration (time_in_stage, time_in_status, every time_in_<status field> twin) orders by the time in the current status: asc = fewest days first, records whose status is empty last; the sort item is the plain {\"field\",\"direction\"} with no extra key. " +
+        "NOT sortable (never put these in sort): multi-value fields (multi_select, signal_select, category, multi_user, multi_record), domain, email, phone, list_entries, " +
+        "linked/lookup fields, and interaction object & interaction-type fields (the first/last email & linkedin interaction objects and the interaction-type selects); sort by the interaction's date sub-field instead. " +
+        "Use the EXACT field key and type from lighthouse_crm_get_attributes; if the user asks to sort by a field whose type is not in the sortable list above, tell them that field can't be sorted rather than guessing a key. " +
+        "RESPONSE VALIDATION META: an unsortable field does NOT fail the search; it comes back in the response's `invalid_sort_fields` array ([{field, reason}]) and the search runs in the default order. If `invalid_sort_fields` is non-empty your sort did not apply: pick a sortable field or tell the user.";
+    const DISCOVERY_FILTER_DESCRIPTION = "Discovery filter object. Format: " +
+        '{"operator":"AND","conditions":[{"field":"<permalink>","operator":"<op>","value":<val>}],"groups":[]}. ' +
+        "IMPORTANT: `field` MUST be one of the prefixed discovery filter keys listed for this entity at the end of this description (company_* or person_*). " +
+        "Those keys are NOT the data fields returned by lighthouse_discovery_get_attributes: a condition whose `field` is a raw data column (e.g. 'categories', 'headquarter_country', 'founded_on') is dropped (it filters nothing) and reported back in the response's `ignored_filter_fields` so you can catch it. " +
+        "For category/industry values, call lighthouse_discovery_get_industries. " +
+        "For location values, call lighthouse_discovery_get_locations and use its `value` field: countries are ISO 3166-1 alpha-2 codes in UPPERCASE (e.g. \"US\", \"GB\", \"DE\"), regions are the region codes it returns. Never pass a lowercase code (\"us\") or a country name (\"United States\"). This applies to EVERY country/region filter key (company_hq_country, company_investor_country, person_country, person_work_country, and the rest). " +
+        "For tag/highlight values, call lighthouse_discovery_get_tags. " +
+        "Fields use prefixed keys (company_name, company_headcount, person_country, etc.). " +
+        "Operators by field type, " +
+        "short_text: contains, is; " +
+        "long_text: contains, not_contains, empty, not_empty; " +
+        "text/url: contains, not_contains, starts_with, ends_with, eq, neq, empty, not_empty; " +
+        "number/currency: between, gt, gte, lt, lte, eq, neq, empty, not_empty; " +
+        "range: between, gt, lt, empty, not_empty; " +
+        "date: after, before, empty, not_empty (empty on a work-experience or stealth date means no entry has that date set, so records with no entries at all also match; created_at fields are never empty); " +
+        "select: contains_any, not_contains_any, empty, not_empty; " +
+        "multi_select: contains_any, not_contains_any, contains_all, empty, not_empty; " +
+        "investor_multi_select: contains_any, not_contains_any, contains_all, empty, not_empty " +
+        "(value is array of investor UUIDs or objects [{\"id\":\"uuid\",\"label\":\"Name\"}]. Call lighthouse_discovery_search_entities with record_type 'investor' to find investor IDs by name); " +
+        "work_experience_multi_select: contains_any, not_contains_any, contains_all, empty, not_empty " +
+        "(value is array of organization UUIDs or objects [{\"id\":\"uuid\",\"label\":\"Name\"}]. Call lighthouse_discovery_search_entities with record_type 'company' to find organization IDs by name); " +
+        "education_multi_select: contains_any, not_contains_any, contains_all, empty, not_empty " +
+        "(value is array of institution UUIDs or objects [{\"id\":\"uuid\",\"label\":\"Name\"}]. Call lighthouse_discovery_search_entities with record_type 'school' to find school IDs by name); " +
+        "funding_type_multi_select: contains_any, not_contains_any, empty, not_empty; " +
+        "multi_user: contains_any, not_contains_any, contains_all, empty, not_empty (value is array of user UUIDs); " +
+        "boolean/checkbox: eq; " +
+        "json: contains, not_contains, empty, not_empty. " +
+        "SPECIAL COMPOUND TYPES, " +
+        "signal_select (company_signals): operators contains_any/not_contains_any/contains_all, value is array of signal strings e.g. [\"new_funding_round\",\"growth_headcount\"]; " +
+        "signal_select (person_signals): operators contains_any/not_contains_any/contains_all, value is {\"signals\":[\"company_registration\",...],\"registration_countries\":[\"US\",\"DE\",...],\"signal_dates\":{\"stealth\":\"2024-03-01\"},\"stealth_predicted_areas\":[\"fintech\",...]} " +
+        "(every key besides signals is optional: registration_countries only filters the company_registration signal by country; " +
+        "signal_dates maps a signal to a 'started on/after' ISO date and applies to stealth / out_of_stealth / founded_new_company; " +
+        "stealth_predicted_areas refines the stealth signal by predicted category group, same values as person_stealth_predicted_area); " +
+        "language_select: operators contains_any/not_contains_any/contains_all, value is {\"languages\":[<ISO 639-1 two-letter codes, e.g. \"en\",\"de\",\"fr\">],\"proficiency\":[<one or more of exactly \"NATIVE_BILINGUAL\",\"EXPERT\",\"ADVANCED\",\"INTERMEDIATE\",\"BASIC\">]} " +
+        "(languages are ISO 639-1 codes; proficiency is optional, omit to match any level, and use those exact uppercase tokens, no other values are accepted). " +
+        "Value formats: text ops → string; number ops → number; between → {\"min\": <num>, \"max\": <num>}; " +
+        "contains_any/not_contains_any/contains_all → array of values; empty/not_empty → omit value; boolean eq → true/false; " +
+        "date ops → ISO date string \"YYYY-MM-DD\". " +
+        "The `operator` of a block (the top level OR any group) is \"AND\" or \"OR\" and joins that block's conditions AND its nested groups: \"AND\" = every one must match, \"OR\" = at least one matches. Set the top-level operator to \"OR\" to OR the top-level conditions, or nest a group to mix logic, e.g. (A OR B) AND C = {\"operator\":\"AND\",\"conditions\":[C],\"groups\":[{\"operator\":\"OR\",\"conditions\":[A,B],\"groups\":[]}]}. A worked example with real keys is in the field-key list below. " +
+        "company_signals value is a plain array of strings; person_signals value is an object {\"signals\":[...],\"registration_countries\"?:[...],\"signal_dates\"?:{...},\"stealth_predicted_areas\"?:[...]}, these are the only contains_any fields whose value is not a bare array. " +
+        "Use the company_*/person_* keys listed below VERBATIM, do not invent variants (no _usd suffix, no abbreviation like hq for headquarter) and do not use the bare permalinks returned by lighthouse_discovery_get_attributes; any unrecognized key is dropped (the search runs as if that condition were absent) and echoed in the response's `ignored_filter_fields`, so ALWAYS check that array, otherwise a mistyped key returns a result that looks fine but is unfiltered. " +
+        "NOT EXPRESSIBLE on this surface (it searches the global database, NOT your CRM): CRM list membership, CRM record owner / unassigned, CRM custom fields, deal stage, role-change dates, and geography finer than country (no US state). If a request needs one of these, apply what you CAN and TELL THE USER which clauses you could not express, do NOT silently drop them or map them onto an unrelated field. " +
+        "Do NOT use CRM attribute keys here. The complete set of valid discovery filter keys for this entity is listed at the end of this description. " +
+        "RESPONSE VALIDATION META: this search NEVER fails on a bad filter; instead the response carries, alongside `items`/`total`, three arrays you MUST inspect (collected recursively across nested groups): " +
+        "`ignored_filter_fields` (keys not recognized; that condition was dropped), " +
+        "`invalid_operators` ([{field, operator}] where the operator is not valid for that field's type; that condition was dropped), and " +
+        "`invalid_logical_operators` ([{operator}] where a group's join was not AND/OR; treated as AND). " +
+        "If ANY are non-empty, part of your filter did NOT apply (results are broader than intended): fix the offending field/operator and retry, or tell the user which clauses could not be applied. A `warnings` array summarizes the same in plain text.";
+    const COMPANY_DISCOVERY_SORT_DESCRIPTION = 'Discovery company sort. Format: {"by":"<field>","dir":"asc"|"desc"}. ' +
+        "ONLY two fields are sortable: founded_on (founding date) and total_funding_amount_usd (total funding raised, in USD). " +
+        "Omit sort to use the default: relevance score, descending. " +
+        "No other field is sortable here (NOT headcount, name, last-funding, etc.); an unsupported `by` is ignored and results fall back to relevance order, with a note in meta.warnings. " +
+        "If the user asks to sort companies by anything else, tell them only founding date and total funding are supported. " +
+        "RESPONSE VALIDATION META: an unsupported sort does NOT fail the search; it comes back in the response's `invalid_sort_fields` array (and `warnings`) and results fall back to relevance order.";
+    const COMPANY_DISCOVERY_FIELDS = " COMPANY FILTER KEYS (use EXACTLY these as the condition `field`; any other key is ignored): " +
+        "Basics: company_name (short_text), company_domain (url), company_description (long_text), company_headcount (number), company_founded_on (date, year), company_created_at (date). " +
+        "Industry: company_categories (multi_select; values from lighthouse_discovery_get_industries → categories), company_sdg_impact (multi_select; values from get_industries → sdg_categories). " +
+        "Signals: company_signals (multi_select; values: new_funding_round, growth_website, growth_headcount, growth_job_posts, growth_lnk_followers, growth_tw_followers, growth_npm, growth_app, growth_patents, bl_launch, hn_launch, gh_launch, prhu_launch, prhu_award). " +
+        "Tags: company_tags (multi_select; values: 2nd_time_founder, serial_founder, has_technical_founder, has_non_technical_founder, raised_previous_funding, has_previous_exit, sales_exp, co_exp, eng_exp, ai_and_data_exp, product_exp, hr_exp, impact_people_tag, a_founder_left, all_founders_left). " +
+        "Funding: company_total_funding (number, USD), company_last_funding_amount (number, USD), company_last_funding_date (date), company_last_funding_type (funding_type_multi_select; values from lighthouse_discovery_get_funding_types, e.g. seed, series_a, plus no_funding to match companies with no recorded funding round). " +
+        "Location: company_hq_country (multi_select; UPPERCASE ISO alpha-2 codes e.g. \"US\", \"GB\" from lighthouse_discovery_get_locations → countries), company_hq_region (multi_select; get_locations → regions), company_hq_city (text), company_german_state (multi_select; German federal states). " +
+        "Socials: company_linkedin, company_twitter, company_facebook, company_github, company_producthunt (url; matches the profile handle/permalink with text operators). " +
+        "Investors (who invested IN this company): company_investor (investor_multi_select; ids from lighthouse_discovery_search_entities record_type 'investor'), company_investor_country (multi_select; get_locations countries), company_investor_region (multi_select; get_locations regions). " +
+        "Investments (the company AS an investor; the investments_top_* keys match the investor's TOP-RANKED preference only, e.g. their #1 country, not every investment they ever made): company_is_investor (checkbox; eq true = the company is itself an investor such as a fund or CVC, eq false = exclude investors), company_num_investments (number; total recorded investments), company_investments_top_category (multi_select; get_industries categories), company_investments_top_sdg (multi_select; get_industries sdg_categories), company_investments_top_country (multi_select; get_locations countries), company_investments_top_region (multi_select; get_locations regions), company_investments_top_stage (funding_type_multi_select; get_funding_types values, no_funding not applicable). " +
+        "Team: company_team_past_companies (work_experience_multi_select; ids from lighthouse_discovery_search_entities record_type 'company'), company_team_education (education_multi_select; ids from lighthouse_discovery_search_entities record_type 'school'), company_team_experience (multi_select; same values as company_tags), company_team_language (language_select), company_team_language_proficiency (multi_select; use with company_team_language to require a proficiency level), company_team_name_origin (multi_select; get_locations countries), company_team_location_country, company_team_location_region, company_team_work_country, company_team_work_region, company_team_edu_country, company_team_edu_region (multi_select; get_locations). " +
+        "CRM (filter the global database by YOUR workspace CRM): company_internal_crm_status (checkbox; eq true = already in your CRM, false = not), company_crm_list_entries (multi_select; companies that are in specific CRM company lists, list ids from lighthouse_crm_list_lists), company_crm_deals_list_entries (multi_select; companies whose deals are in specific deal lists), company_crm_team_network (multi_user; companies whose team members are connected to specific workspace users, ids from lighthouse_workspace_list_users), company_crm_team_list_entries (multi_select; companies whose team members are in specific people lists), company_external_crm_status (checkbox; needs a connected external CRM), company_external_crm_lists (multi_select; needs a connected external CRM). " +
+        'NESTED-GROUP EXAMPLE for "headcount 10-50 AND (HQ in US or UK) AND raised Series A": ' +
+        '{"operator":"AND","conditions":[{"field":"company_headcount","operator":"between","value":{"min":10,"max":50}},{"field":"company_last_funding_type","operator":"contains_any","value":["series_a"]}],"groups":[{"operator":"OR","conditions":[{"field":"company_hq_country","operator":"contains_any","value":["US","GB"]}],"groups":[]}]} ' +
+        "(country codes from get_locations, funding-type values from get_funding_types).";
+    const PERSON_DISCOVERY_FIELDS = " PERSON FILTER KEYS (use EXACTLY these as the condition `field`; any other key is ignored): " +
+        "Basics: person_name (short_text), person_created_at (date). " +
+        "Investments (the person AS an investor, e.g. an angel; the investments_top_* keys match the investor's TOP-RANKED preference only, e.g. their #1 country, not every investment they ever made): person_is_investor (checkbox; eq true = only investors, eq false = exclude investors), person_num_investments (number; total recorded investments), person_investments_top_category (multi_select; get_industries categories), person_investments_top_sdg (multi_select; get_industries sdg_categories), person_investments_top_country (multi_select; get_locations countries), person_investments_top_region (multi_select; get_locations regions), person_investments_top_stage (funding_type_multi_select; get_funding_types values, no_funding not applicable). " +
+        "Industry: person_current_categories, person_past_categories (multi_select; values from lighthouse_discovery_get_industries → categories), person_current_sdg_impact, person_past_sdg_impact (multi_select; get_industries → sdg_categories). " +
+        "Signals: person_signals (signal_select; value {\"signals\":[...],\"registration_countries\"?:[...],\"signal_dates\"?:{<signal>:\"YYYY-MM-DD\"},\"stealth_predicted_areas\"?:[...]}), person_registration_country (multi_select; filters company_registration signals by country, get_locations countries). " +
+        "Tags: person_tags (multi_select; values: phd_doctorate, 2nd_time_founder, serial_founder, has_exit, raised_funding, sales_exp, co_exp, eng_exp, ai_and_data_exp, product_exp, hr_exp). " +
+        "Language & origin: person_language (language_select), person_language_proficiency (multi_select; use with person_language to require a proficiency level), person_name_origin (multi_select; get_locations countries). " +
+        "Current location: person_country (multi_select; UPPERCASE ISO alpha-2 codes e.g. \"US\", \"GB\" from lighthouse_discovery_get_locations → countries), person_region (multi_select; get_locations → regions), person_german_state (multi_select; German federal states). " +
+        "Experience: person_past_companies (work_experience_multi_select; ids from lighthouse_discovery_search_entities record_type 'company'), person_education (education_multi_select; ids from lighthouse_discovery_search_entities record_type 'school'), person_experience_start_date, person_experience_end_date (date; matches people with at least one work experience whose start/end date passes the bound, independent of the other experience conditions), person_work_country, person_work_region, person_edu_country, person_edu_region (multi_select; get_locations). " +
+        "Stealth: person_stealth_start_date, person_stealth_end_date (date), person_stealth_predicted_area (multi_select; the predicted category-GROUP a stealth founder is building in. Values: agriculture_farming, ai_ml, apparel_fashion, ar_vr, cloud_devops, commerce, consumer_goods_electronics, content_publishing, crypto_blockchain, customer_service, data_analytics, deeptech, design, edtech, energy, engineering_applied_sciences, entertainment_recreation, events, financial_services_fintech, food_beverage, gaming, geospatial_technologies, hardware, healthtech_biotech, hospitality_travel, hr, impact, industrial_manufacturing, infrastructure, it_software, legal, miscellaneous, natural_resources, public_sector_defense, real_estate, sales_marketing, security_privacy_risk, sharing_economy, social_communities, sports, telecommunications, transportation_mobility_logistics). " +
+        "Primary company: person_company_hq_country, person_company_hq_region (multi_select; get_locations), person_company_headcount (number), person_company_founded_on (date), person_company_total_funding, person_company_last_funding_amount (number, USD), person_company_last_funding_date (date), person_company_last_funding_type (funding_type_multi_select; values from lighthouse_discovery_get_funding_types, including no_funding). " +
+        "CRM: person_internal_crm_status (checkbox; eq true/false), person_crm_network (multi_user; ids from lighthouse_workspace_list_users), person_external_crm_status (checkbox; needs a connected external CRM), person_external_crm_lists (multi_select; needs a connected external CRM). " +
+        'NESTED-GROUP EXAMPLE for "(based in Germany or France) AND a technical or AI/data background": ' +
+        '{"operator":"AND","conditions":[],"groups":[{"operator":"OR","conditions":[{"field":"person_country","operator":"contains_any","value":["DE","FR"]}],"groups":[]},{"operator":"OR","conditions":[{"field":"person_tags","operator":"contains_any","value":["eng_exp","ai_and_data_exp"]}],"groups":[]}]} ' +
+        "(an outer AND of two OR groups; country codes from get_locations).";
+    server.registerTool("lighthouse_crm_get_attributes", {
+        title: "Get CRM Attributes",
+        description: "Get a lightweight catalog of the fields for a CRM record type: each field's permalink, label, data_type, links_to, read_only, is_custom, has_options, and source_field. " +
+            "`source_field` names the status attribute a `duration` attribute is derived from (null on every other attribute); such attributes (time_in_stage on deals, time_in_status on tasks, time_in_<status> beside a custom status field) are read-only and computed, never written. " +
+            "ALWAYS call this before building filters for search_records / list_records or creating/updating views. Use the exact permalinks it returns. " +
+            "To keep the response small it does NOT include select/multi_select option values: when a field has has_options=true, call lighthouse_crm_list_options with that permalink to get its allowed values before filtering or setting it. " +
+            "Supports built-in types (company, person, deal, task) and custom objects (use the object's permalink, e.g. 'lp', 'project'). " +
+            "When called without record_type, returns all types including custom objects as top-level keys.",
+        inputSchema: {
+            record_type: z
+                .string()
+                .optional()
+                .describe("Record type: 'company', 'person', 'deal', 'task', or a custom object permalink. Omit to get all types."),
+            list: z
+                .string()
+                .optional()
+                .describe("List ID (UUID) to scope attributes. Returns global fields plus list-scoped custom fields. If provided without record_type, auto-resolves the list's entity type."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/records/attributes", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_attribute", {
+        title: "Get CRM Attribute",
+        description: "Get a single custom field definition. Response returns 'permalink', 'is_custom', 'data_type', 'links_to'. " +
+            "For custom objects, use the object's permalink as record_type (e.g. 'lp').",
+        inputSchema: {
+            permalink: z.string().describe("Field permalink (unique key) of the attribute"),
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', 'task', or a custom object permalink"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/attributes/${params.record_type}/${params.permalink}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_attribute", {
+        title: "Create CRM Attribute",
+        description: "Create a new custom field in your CRM workspace. " +
+            "Types: text, number, currency, percentage, date, datetimez, select, multi_select, status, checkbox, url, email, phone, rating, record, multi_record, user, multi_user. " +
+            "Supports custom objects, use the object's permalink as record_type (e.g. 'lp'). " +
+            "For record/multi_record fields, links_to can be a built-in type or a custom object permalink.",
+        inputSchema: {
+            label: z.string().describe("Display label for the field"),
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', or a custom object permalink (e.g. 'lp')"),
+            data_type: z
+                .enum([
+                "text",
+                "number",
+                "currency",
+                "percentage",
+                "date",
+                "datetimez",
+                "select",
+                "multi_select",
+                "status",
+                "checkbox",
+                "url",
+                "email",
+                "phone",
+                "rating",
+                "record",
+                "multi_record",
+                "user",
+                "multi_user",
+            ])
+                .describe("Field type. One of: text, number, currency, percentage, date, datetimez, select, multi_select, status, checkbox, url, email, phone, rating, record, multi_record, user, multi_user."),
+            permalink: z.string().optional().describe("Unique identifier for the field. Auto-generated from label if omitted."),
+            links_to: z.string().optional().describe("For record/multi_record fields: which record type to link to (e.g. 'company', 'deal', or a custom object permalink like 'lp')"),
+            options: z
+                .array(z.record(z.unknown()))
+                .optional()
+                .describe("For select/multi_select/status fields: array of {value, label} option objects"),
+            list: z
+                .string()
+                .optional()
+                .describe("List ID (UUID) to scope this attribute to a specific list. Omit for global (workspace-wide) attributes."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/attributes", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_attribute", {
+        title: "Update CRM Attribute",
+        description: "Update a custom field's display label (the field type, linked record type, and options are fixed after creation). " +
+            "For custom objects, use the object's permalink as record_type.",
+        inputSchema: {
+            permalink: z.string().describe("Field permalink of the attribute to update"),
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', or a custom object permalink"),
+            label: z.string().describe("New display label"),
+        },
+    }, async (params) => {
+        try {
+            const { permalink, record_type, ...body } = params;
+            const res = await api.patch(`/attributes/${record_type}/${permalink}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_attribute", {
+        title: "Delete CRM Attribute",
+        description: "Delete a custom field and all its data. Only custom fields can be deleted, not system fields. " +
+            "For custom objects, use the object's permalink as record_type.",
+        inputSchema: {
+            permalink: z.string().describe("Field permalink of the attribute to delete"),
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', or a custom object permalink"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/attributes/${params.record_type}/${params.permalink}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_color_palette", {
+        title: "Get Color Palette",
+        description: "Get the available color palette for select/multi_select/status field options. " +
+            "Returns an array of {hex_code, label} objects. " +
+            "Use this to discover valid hex color codes when creating or updating select options.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/attributes/colors");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_options", {
+        title: "List CRM Field Options",
+        description: "Get the allowed values (value, label, color) for a CRM select / multi_select field. " +
+            "Call this when lighthouse_crm_get_attributes shows has_options=true for a field and you need its values before filtering or setting it. " +
+            "Results are paginated (max 100 per page): use `search` to narrow by label, and `limit` / `offset` to page through a field with many options. " +
+            "For custom objects, use the object's permalink as record_type.",
+        inputSchema: {
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', 'task', or a custom object permalink"),
+            permalink: z.string().describe("Field permalink of the select/multi_select field"),
+            search: z.string().optional().describe("Filter options whose label contains this text (case-insensitive)"),
+            limit: z.number().optional().describe("Max options to return (default 100, max 100)"),
+            offset: z.number().optional().describe("Number of options to skip for pagination (default 0)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/records/options", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_option", {
+        title: "Create CRM Field Option",
+        description: "Add a new option to a select/multi_select field. The option value is auto-generated from the label. " +
+            "Re-creating a system default option that was previously removed restores it (its original color and label are kept). " +
+            "Returns the updated list of all options for the field (each with value, label, color). " +
+            "For custom objects, use the object's permalink as record_type. " +
+            "Options can only be created on company, person, deal, and custom objects.",
+        inputSchema: {
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', or a custom object permalink"),
+            permalink: z.string().describe("Field permalink of the select/multi_select field"),
+            label: z.string().describe("Option display label"),
+            color: z.string().optional().describe("Option color (hex code from palette, auto-assigned if omitted)"),
+        },
+    }, async (params) => {
+        try {
+            const { record_type, permalink, ...body } = params;
+            const res = await api.post(`/options/${record_type}/${permalink}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_option", {
+        title: "Delete CRM Field Option",
+        description: "Delete an option value from a select/multi_select field. Custom options are removed permanently; a system default option is disabled for the workspace instead (re-create it to restore). " +
+            "For custom objects, use the object's permalink as record_type.",
+        inputSchema: {
+            record_type: z.string().describe("Record type: 'company', 'person', 'deal', 'task', or a custom object permalink"),
+            permalink: z.string().describe("Field permalink of the select/multi_select field"),
+            value: z.string().describe("Option value to delete"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/options/${encodeURIComponent(params.record_type)}/${encodeURIComponent(params.permalink)}/${encodeURIComponent(params.value)}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_search_records", {
+        title: "Search CRM Records",
+        description: "Search and filter records in YOUR CRM workspace (companies, people, or deals you've added). " +
+            "Supports filters, sorting, pagination, and saved views. " +
+            "A search by MEANING over people or company records is a semantic_search condition in filters; it needs the ready vector of a saved view (lighthouse_crm_get_view) or of a condition copied from the app, never text and never a vector you wrote (the filters description has the rule). " +
+            "NEVER guess field keys, ALWAYS call lighthouse_crm_get_attributes first to get the exact field keys " +
+            "for the record_type, then use those keys in your filter conditions. " +
+            "The response's `meta` includes `total` (an integer match count) and `ignored_filter_fields` (any filter key that is not a valid attribute for this record_type, each with a did_you_mean suggestion when a close match can be computed). Check `ignored_filter_fields` to confirm every filter was actually applied. " +
+            "NOT for discovering new companies/people, use lighthouse_discovery_* tools for that.",
+        inputSchema: {
+            record_type: z.string().describe("Record type (company, person, deal, or custom object permalink)"),
+            filters: z
+                .record(z.unknown())
+                .optional()
+                .describe(CRM_FILTER_DESCRIPTION),
+            sort: z
+                .array(z.record(z.unknown()))
+                .optional()
+                .describe(CRM_SORT_DESCRIPTION),
+            limit: z.number().min(1).max(100).default(25).describe("Records per page (max 100)"),
+            offset: z.number().min(0).default(0).describe("Number of records to skip"),
+            view_id: z
+                .string()
+                .uuid()
+                .optional()
+                .describe("Load saved filters/sort from a view. User-provided filters override view filters."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/records/search", {
+                record_type: params.record_type,
+                filters: params.filters,
+                sort: params.sort,
+                limit: params.limit,
+                offset: params.offset,
+                view_id: params.view_id,
+            });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Search failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_record", {
+        title: "Get CRM Record",
+        description: "Get a single CRM record by ID with all fields and relationships. Custom fields are returned as top-level keys, not nested under an attributes object. " +
+            "Signal fields (company_signals on companies, person_signals on people) are arrays of signal objects, one per signal: { signal (the value), picked_up_on (ISO 8601 date, the day the feed picked it up), occurrences (the number of windows or registrations behind it, 1 otherwise), and what the feed knows: " +
+            "for a company measured_on, timeframe, change_percent, value (the metric's value on measured_on, from the most recently measured window), windows (every window, each its own snapshot: [{timeframe, change_percent, value, measured_on, picked_up_on}]), money_raised_usd, investment_type, announced_on, investment_stage, num_investors, pre_money_valuation_usd; " +
+            "for a person started_on, ended_on, registered_on, company ({id, name, domain, linkedin, logo_url}), entity_name, role, entity_description, industries, domain, founded_on, country, country_name, city, county, state, register_url, registrations (every registration: [{entity_name, registered_on, city, country, country_name, register_url, role, picked_up_on}]), predicted_areas ([{permalink, label, origin}]), out_of_stealth_reason, github, bio, explanation }. " +
+            "Filter these fields by the signal VALUES (strings). Search results carry the same shape. " +
+            "Two more read-only keys on a company: investors ({ company: [{ database_id, crm_id, name, avatar_url, is_lead }], person: [{ database_id, crm_id, first_name, last_name, avatar_url, is_lead }] }: the global database's investors of the company, both keys always present; database_id = the investor's id in the database tools and the value the investors filter takes, crm_id = the workspace's CRM record linked to that investor or null when it is not in the CRM, is_lead = led one of its rounds) and headcount_growth ({ \"1m\", \"3m\", \"6m\", \"1y\" }: the headcount's percent change per window, null when unknown, plus value = the headcount on measured_on; null when the record has no linked profile or no data). " +
+            "Two read-only keys on a person: experience and education ([{ database_id, crm_id, name, avatar_url }]: the companies the linked global profile worked at and the schools it studied at, always present, [] without a linked profile; database_id = the id in the database tools and the value the experience / education filters take, crm_id = the workspace's CRM company linked to that company or school, null when it is not in the CRM). " +
+            "A third read-only key on every company, person, deal and custom object record: notes ({ count, last_note_at, notes: [ { id, title, type, created_at, created_by, tags, records, meeting } ] }: the notes linked to the record, the newest five with the author, the kind, the tags, the other records they link to and the meeting details of a meeting note; never the body, which lighthouse_crm_get_note reads; count is every note the caller may see). " +
+            "A read-only duration twin sits beside every status field (time_in_stage on a deal, time_in_status on a task, time_in_<status field> beside a custom status field; lighthouse_crm_get_attributes lists each with its source_field): { days, since } (the whole days the record has held its current status and the ISO timestamp since when), null while the status is empty. " +
+            "(Discovery profiles keep their own signals list: one row per feed window with type, created_at, timeframe, percentage_change.)",
+        inputSchema: {
+            record_type: z.string().describe("Record type (company, person, deal, or custom object permalink)"),
+            id: z.string().uuid().describe("Record ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/records/${params.record_type}/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_record_activity", {
+        title: "Get Record Activity",
+        description: "Read the activity feed of one CRM record, newest first: who changed what, when, and from where. Use it to answer questions about history (\"what changed on this deal last week\", \"who moved it to won\", \"which fields has nobody touched\") instead of guessing from the record's current values. " +
+            "Each entry has: action (created / updated / deleted / merged), occurred_at, summary (a ready-made sentence, ending \"via <the source>\" when a workflow or an API key made the change rather than a person, since both log a human as the actor), target ({ record_type, id, name }; the feed also carries the notes and tasks attached to the record, so the target is not always the record itself), actor (null for automated changes), and source. " +
+            "source always has { type, label }: type is app / mobile / api / mcp / workflow / ai_assistant / notetaker / email_sync / calendar_sync / linkedin_sync / inbound_email / inbound_whatsapp / lp_portal / sync, and label names the exact origin. The four trace keys are always present and null when the origin did not record them: workflow is { id, name, run_id, node_id } when a workflow made the change (tracing an entry back to the exact run and step), api_key_id / mcp_tool identify the key or AI tool behind an API change, and trigger is automatic or manual where the origin recorded whether a person asked for the change (meeting notes written on their own and notes a member asked for both log that member as the actor, so trigger is what tells them apart). " +
+            "changes[] holds the field edits: { field, label, data_type, is_custom, list, previous, current }, where previous and current are each { value, display }: value is what is stored (an option value, a uuid, a number) and display is the same thing resolved for humans (an option's label, a linked record or user object). Consecutive edits to the same field by the same person on the same day are collapsed into one entry, so previous is the value before the burst and current the value after it. " +
+            "Every entry has id, activity_id, action, occurred_at, summary, actor, source, target and changes. One save that changed several fields is reported as one entry per field: id stays unique per entry, activity_id is shared by the entries from that same save.  The five detail keys are on every entry and null on the entries they do not describe: note and task carry that note's / task's body inline (no follow-up call needed), merge carries { merged_record, kept_record }, document carries { type, id, name } for an attached file or folder, and related_records (an empty array when there are none) lists the OTHER records when one activity spanned several (never the entry's own target, which is already under target, and never the record whose feed this is). " +
+            "record_type is company, person, deal, or a custom object permalink; pass task or note to read a task's or note's own history. " +
+            "SCOPE: the feed covers records, notes and tasks being created, updated, deleted and merged, plus files and folders being attached. It does NOT record list membership changes or detaching a document, so do not present it to the user as a complete audit trail.",
+        inputSchema: {
+            record_type: z.string().describe("Record type (company, person, deal, a custom object permalink, or task / note)"),
+            id: z.string().uuid().describe("Record ID"),
+            limit: z.number().min(1).max(100).default(25).describe("Entries per page (max 100)"),
+            offset: z.number().min(0).default(0).describe("Entries to skip. meta.total and meta.has_more say whether more remain"),
+        },
+    }, async ({ record_type, id, limit, offset }) => {
+        try {
+            const res = await api.get(`/records/${record_type}/${id}/activity`, { limit, offset });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_ai_reports", {
+        title: "List AI Reports on a Record",
+        description: "The AI reports generated on one CRM record (any record type: company, person, deal, or a custom object permalink), newest first: the memos, SWOTs, teardowns, pass memos and briefs a member generated from the record's AI Reports tab in Lighthouse. " +
+            "WHEN TO USE: the user asks whether a memo or report already exists on a record, what the last one said, wants to compare or build on an earlier report, or asks about a company's \"memo\" / \"analysis\" / \"write-up\" (check here before writing one from scratch). Not for dashboards or charts (those are lighthouse_reports_*), and nothing here generates a report: that happens in the app. " +
+            "Each row: id, name, status (processing / success / error), depth (short / standard / extensive), template, partial (true when the run hit a cap), summary (one paragraph of the report's own prose), created_by { id, name }, created_at, completed_at. Only a success report has a document: read it with lighthouse_crm_get_ai_report. " +
+            "A report quoting a mailbox, calendar, LinkedIn account or file the API key's user cannot read is left out of the list (its author always sees it).",
+        inputSchema: {
+            record_type: z.string().describe("Record type: company, person, deal, or a custom object permalink"),
+            id: z.string().uuid().describe("Record ID"),
+            limit: z.number().min(1).max(50).default(25).describe("Reports per page (max 50)"),
+            offset: z.number().min(0).default(0).describe("Reports to skip; meta.total and meta.has_more say whether more remain"),
+        },
+    }, async ({ record_type, id, limit, offset }) => {
+        try {
+            const res = await api.get(`/records/${encodeURIComponent(record_type)}/${id}/ai-reports`, { limit, offset });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_ai_report", {
+        title: "Get AI Report",
+        description: "One AI report by id (from lighthouse_crm_list_ai_reports): the same metadata plus record_type / record_id and content, the full document as Markdown with its section headings (citation markers removed). " +
+            "WHEN TO USE: the user wants what an earlier memo or report actually says (a section, a number, a recommendation), or a comparison with it. A report can be long: quote or summarise the part the question is about rather than echoing it whole. " +
+            "content is null while the report is still processing or failed. Answers 403 naming the channel when the report draws on a shared mailbox, calendar, LinkedIn account or document the API key's user cannot read, and 404 for an unknown id.",
+        inputSchema: {
+            id: z.string().uuid().describe("Report ID from lighthouse_crm_list_ai_reports"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/ai-reports/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_record", {
+        title: "Create CRM Record",
+        description: "Create a new CRM record. Pass all fields (standard + custom) in a single flat data object, " +
+            "the API splits standard vs custom fields automatically. " +
+            "BEFORE calling this tool, call lighthouse_crm_get_attributes to discover available field keys and types for the record_type. " +
+            "A name is strongly recommended for every record: company → name (string). person → fn or first_name (string). deal → name (string). " +
+            "custom objects → name (string) is the only standard field; all other fields are custom. " +
+            "If you omit the name, the record is still created but stored with the name \"Unnamed\", so always provide one when you can. " +
+            "IMPORTANT data format rules (company/person/deal ONLY, custom objects do NOT have relation fields): " +
+            "domain (company) → ALWAYS pass as array of strings, even for one domain: [\"acme.com\"]. " +
+            "associated_people (company) → array of person UUIDs (or {id} objects). " +
+            "associated_deals (company) → array of deal UUIDs. " +
+            "emails (person) → array of email strings: [\"john@acme.com\"]. " +
+            "phones (person) → array of objects: [{\"prefix\":\"+1\",\"number\":\"5551234\"}]. " +
+            "associated_companies (person/deal) → array of company UUIDs. " +
+            "associated_people (deal) → array of person UUIDs. " +
+            "owner (deal) → UUID string of the owner user. " +
+            "Custom fields use their field permalink as the key. A custom rating field's value is an integer 1-5 (or null to clear). " +
+            "The response returns all fields as top-level keys (custom fields are NOT nested under an attributes object).",
+        inputSchema: {
+            record_type: z.string().describe("Record type (company, person, deal, or custom object permalink)"),
+            data: z.record(z.unknown()).describe("All record fields, standard, custom, and relations in a single flat object"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post(`/records/${params.record_type}`, {
+                data: params.data,
+            });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_record", {
+        title: "Update CRM Record",
+        description: "Update an existing CRM record. Only include the fields you want to change. " +
+            "Standard and custom fields can be mixed in a single flat data object, the API splits them automatically. " +
+            "BEFORE calling this tool, call lighthouse_crm_get_attributes to discover available field keys and types. " +
+            "Relation and multi-value fields (domain, associated_people, associated_deals, emails, phones, associated_companies, and custom multi_select/multi_record/multi_user) " +
+            "support two modes (company/person/deal ONLY; custom objects have only 'name' and custom fields): " +
+            "(1) pass a bare ARRAY to REPLACE the whole field, e.g. domain: [\"acme.com\"], or an empty array [] to clear it (remove all); " +
+            "(2) pass { \"add\": [...] } and/or { \"remove\": [...] } to append or remove items WITHOUT fetching first, " +
+            "e.g. domain: { \"add\": [\"new.com\"] } appends one domain, associated_people: { \"remove\": [\"<uuid>\"] } removes one member. " +
+            "Use add/remove to avoid a get-then-merge round-trip; it is also the only safe way to change one relation member without disturbing the others. " +
+            "Field formats: " +
+            "domain (company) → array of strings: [\"acme.com\"]. " +
+            "associated_people (company) → array of person UUIDs. " +
+            "emails (person) → array of email strings. " +
+            "phones (person) → array of objects: [{\"prefix\":\"+1\",\"number\":\"5551234\"}]. " +
+            "associated_companies (person/deal) → array of company UUIDs. " +
+            "associated_people (deal) → array of person UUIDs. " +
+            "associated_deals (company/person) → array of deal UUIDs. " +
+            "A custom rating field's value → an integer 1-5 (or null to clear). " +
+            "The response returns all fields as top-level keys (custom fields are NOT nested under an attributes object).",
+        inputSchema: {
+            record_type: z.string().describe("Record type (company, person, deal, or custom object permalink)"),
+            id: z.string().uuid().describe("Record ID"),
+            data: z.record(z.unknown()).describe("Fields to update, standard, custom, and relations in a single flat object"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.patch(`/records/${params.record_type}/${params.id}`, {
+                data: params.data,
+            });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_upsert_record", {
+        title: "Upsert CRM Record",
+        description: "Find-or-create a CRM record by a UNIQUE attribute: if a record already matches the value it is updated, otherwise a new one is created. " +
+            "Only person and company support upsert, person matches on email or linkedin, company on domain or linkedin (set matching_attribute accordingly). " +
+            "The value to match on MUST be present in data (e.g. with matching_attribute 'email', include emails: [\"jane@acme.com\"]; with 'domain', include domain: [\"acme.com\"]; with 'linkedin', include linkedin: \"...\"). " +
+            "All other field rules (including the { add, remove } append/remove syntax) are the same as lighthouse_crm_update_record. " +
+            "Use this instead of create when you might be re-importing the same person/company and want to avoid duplicates.",
+        inputSchema: {
+            record_type: z.enum(["person", "company"]).describe("Only person or company can be upserted"),
+            matching_attribute: z
+                .enum(["email", "domain", "linkedin"])
+                .describe("Unique attribute to match on: person → email or linkedin; company → domain or linkedin"),
+            data: z.record(z.unknown()).describe("Record fields, MUST include the matching attribute's value so a created record carries it"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.put(`/records/${params.record_type}?matching_attribute=${params.matching_attribute}`, { data: params.data });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_record", {
+        title: "Delete CRM Record",
+        description: "Permanently delete a CRM record. For custom objects, use the object's permalink as record_type.",
+        inputSchema: {
+            record_type: z.string().describe("Record type: company, person, deal, or a custom object permalink"),
+            id: z.string().uuid().describe("Record ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/records/${params.record_type}/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_bulk_create_records", {
+        title: "Bulk Create CRM Records",
+        description: "Create up to 100 CRM records of the same record_type in one call. " +
+            "Each item in `records` is a flat data object, the SAME shape you'd pass as `data` to lighthouse_crm_create_record. " +
+            "BEFORE calling, call lighthouse_crm_get_attributes to discover field keys and types. " +
+            "Partial success: the response returns a `results` array (one entry per item, in order, with success/data/error) and a `summary` " +
+            "({total, succeeded, failed}). A failed item does NOT roll back the others. " +
+            "Same per-record field rules as lighthouse_crm_create_record (domain as array, emails as array, owner as UUID, etc.).",
+        inputSchema: {
+            record_type: z.string().describe("Record type for ALL items (company, person, deal, or a custom object permalink)"),
+            records: z
+                .array(z.record(z.unknown()))
+                .min(1)
+                .max(100)
+                .describe("Array of flat data objects (max 100), one per record to create"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post(`/records/${params.record_type}/bulk`, { records: params.records });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_bulk_update_records", {
+        title: "Bulk Update CRM Records",
+        description: "Update up to 100 CRM records of the same record_type in one call. " +
+            "Each item in `records` is { id, data }, `id` is the record UUID and `data` is a flat object of the fields to change " +
+            "(same shape as lighthouse_crm_update_record). " +
+            "Relation and multi-value fields are REPLACED per item when you pass a bare array (send [] to clear); to append or remove without fetching first, pass { add: [...] } / { remove: [...] } per field (same as lighthouse_crm_update_record). " +
+            "Partial success: the response returns a `results` array (one entry per item, in order, with success/data/error) and a `summary` ({total, succeeded, failed}).",
+        inputSchema: {
+            record_type: z.string().describe("Record type for ALL items (company, person, deal, or a custom object permalink)"),
+            records: z
+                .array(z.object({
+                id: z.string().uuid().describe("Record UUID to update"),
+                data: z.record(z.unknown()).describe("Flat object of fields to change"),
+            }))
+                .min(1)
+                .max(100)
+                .describe("Array of { id, data } items (max 100)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.patch(`/records/${params.record_type}/bulk`, { records: params.records });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_bulk_upsert_records", {
+        title: "Bulk Upsert CRM Records",
+        description: "Find-or-create up to 100 records of the same record_type in one call, each matched on a unique attribute. " +
+            "For each item, if a record already matches the value it is updated, otherwise a new one is created. " +
+            "Person matches on email or linkedin, company on domain or linkedin (set matching_attribute for the whole batch). " +
+            "Each item in `records` is a flat data object that MUST include the matching attribute's value (e.g. matching_attribute 'email' means each item includes emails: [\"...\"]). " +
+            "Only person and company support upsert; deals and custom objects do not. " +
+            "Partial success: the response returns a `results` array (one entry per item, in order, with success/created/data/error) and a `summary` ({total, succeeded, failed}). " +
+            "Ideal for re-importing a batch of people or companies without creating duplicates.",
+        inputSchema: {
+            record_type: z.enum(["person", "company"]).describe("Only person or company can be upserted"),
+            matching_attribute: z
+                .enum(["email", "domain", "linkedin"])
+                .describe("Unique attribute to match on for ALL items: person uses email or linkedin; company uses domain or linkedin"),
+            records: z
+                .array(z.record(z.unknown()))
+                .min(1)
+                .max(100)
+                .describe("Array of flat data objects (max 100); each MUST include the matching attribute's value"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.put(`/records/${params.record_type}/bulk?matching_attribute=${params.matching_attribute}`, { records: params.records });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_bulk_delete_records", {
+        title: "Bulk Delete CRM Records",
+        description: "Permanently delete up to 100 CRM records of the same record_type in one call. " +
+            "Pass `ids` as an array of record UUIDs. " +
+            "Partial success: the response returns a `results` array (one entry per id, in order, with success/error) and a `summary` ({total, succeeded, failed}).",
+        inputSchema: {
+            record_type: z.string().describe("Record type for ALL ids (company, person, deal, or a custom object permalink)"),
+            ids: z.array(z.string().uuid()).min(1).max(100).describe("Array of record UUIDs to delete (max 100)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/records/${params.record_type}/bulk`, { ids: params.ids });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_list", {
+        title: "Create CRM List",
+        description: "Create a new CRM list to organize records. Supports companies, people, deals, and custom objects. " +
+            "Defaults to 'private' visibility. " +
+            "To share with specific teams after creation, use lighthouse_crm_share_list_with_teams. " +
+            "Requires lists.edit permission.",
+        inputSchema: {
+            name: z.string().describe("List name"),
+            record_type: z.string().describe("Record type for this list: 'company', 'person', 'deal', or a custom object permalink (e.g. 'lp', 'project')"),
+            sharing: z.enum(["private", "workspace"]).default("private").optional().describe("Visibility: 'private' (default) or 'workspace'"),
+            color: z.string().optional().describe("Hex color code for the list"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/lists", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_lists", {
+        title: "List CRM Lists",
+        description: "Get all CRM lists in your workspace. Each list's record_type is 'company', 'person', 'deal', or a custom object permalink (e.g. 'lp', 'project'), and that is the record type of everything in it.",
+        inputSchema: {
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/lists", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_list", {
+        title: "Get CRM List",
+        description: "Get a single CRM list by ID with its configuration. Its record_type is 'company', 'person', 'deal', or a custom object permalink (e.g. 'lp', 'project').",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/lists/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_list", {
+        title: "Update CRM List",
+        description: "Update a CRM list's name or configuration.",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+            name: z.string().optional().describe("New list name"),
+            sharing: z.enum(["private", "workspace"]).optional().describe("New visibility setting"),
+            color: z.string().optional().describe("New hex color code"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.patch(`/lists/${id}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_list", {
+        title: "Delete CRM List",
+        description: "Permanently delete a CRM list.",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/lists/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_list_records", {
+        title: "Get List Records",
+        description: "Get records in a CRM list with optional filtering, sorting, and view support. " +
+            "Same filter format as search_records. To get valid filter keys, call lighthouse_crm_get_attributes with this list's record_type, which is 'company', 'person', 'deal', or a custom object permalink. " +
+            "The response's `meta` includes `total` (an integer match count) and `ignored_filter_fields` (any filter key that is not a valid attribute for this list's record type, each with a did_you_mean suggestion when a close match can be computed). Check `ignored_filter_fields` to confirm every filter was actually applied.",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+            filters: z.record(z.unknown()).optional().describe(CRM_FILTER_DESCRIPTION),
+            sort: z.array(z.record(z.unknown())).optional().describe(CRM_SORT_DESCRIPTION),
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+            view_id: z.string().uuid().optional().describe("Load saved filters/sort from a view. User-provided filters override view filters."),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.post(`/lists/${id}/records/search`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_add_to_list", {
+        title: "Add Record to List",
+        description: "Add a CRM record to a list. The record type is inferred from the list, so the record must be of the list's record_type: 'company', 'person', 'deal', or a custom object permalink.",
+        inputSchema: {
+            list_id: z.string().uuid().describe("List ID"),
+            record_id: z.string().uuid().describe("Record ID to add"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post(`/lists/${params.list_id}/records`, {
+                record_id: params.record_id,
+            });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_remove_from_list", {
+        title: "Remove Record from List",
+        description: "Remove a record from a CRM list. The record type is inferred from the list, whose record_type is 'company', 'person', 'deal', or a custom object permalink.",
+        inputSchema: {
+            list_id: z.string().uuid().describe("List ID"),
+            record_id: z.string().uuid().describe("Record ID to remove"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/lists/${params.list_id}/records/${params.record_id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_bulk_add_to_list", {
+        title: "Bulk Add Records to List",
+        description: "Add up to 100 CRM records to a list in one call. The record type is inferred from the list, so every id must be of the list's record_type: 'company', 'person', 'deal', or a custom object permalink. " +
+            "Partial success: the response returns a `results` array (one entry per id, in order, with success/error) and a `summary` ({total, succeeded, failed}). " +
+            "A failed id does NOT prevent the others from being added.",
+        inputSchema: {
+            list_id: z.string().uuid().describe("List ID"),
+            record_ids: z.array(z.string().uuid()).min(1).max(100).describe("Array of record UUIDs to add (max 100)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post(`/lists/${params.list_id}/records/bulk`, { record_ids: params.record_ids });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_bulk_remove_from_list", {
+        title: "Bulk Remove Records from List",
+        description: "Remove up to 100 CRM records from a list in one call. Every id must be of the list's record_type: 'company', 'person', 'deal', or a custom object permalink. " +
+            "Partial success: the response returns a `results` array (one entry per id, in order, with success/error) and a `summary` ({total, succeeded, failed}).",
+        inputSchema: {
+            list_id: z.string().uuid().describe("List ID"),
+            record_ids: z.array(z.string().uuid()).min(1).max(100).describe("Array of record UUIDs to remove (max 100)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/lists/${params.list_id}/records/bulk`, { record_ids: params.record_ids });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_share_list_with_teams", {
+        title: "Share List with Teams",
+        description: "Grant team-level access to a CRM list. Only the list owner can share. " +
+            "Use lighthouse_workspace_list_teams to find team IDs first. " +
+            "Requires lists.share permission. " +
+            "Returns formatted list: {id, name, record_type, sharing, color, count, owner, shared_with_teams, created_at, updated_at}, where record_type is 'company', 'person', 'deal', or a custom object permalink.",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+            team_ids: z.array(z.string().uuid()).describe("Array of team UUIDs to grant access to"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.post(`/lists/${id}/teams`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_revoke_list_from_teams", {
+        title: "Revoke List Team Access",
+        description: "Revoke team-level access from a CRM list. Only the list owner can revoke. " +
+            "Requires lists.share permission. " +
+            "Returns formatted list: {id, name, record_type, sharing, color, count, owner, shared_with_teams, created_at, updated_at}, where record_type is 'company', 'person', 'deal', or a custom object permalink.",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+            team_ids: z.array(z.string().uuid()).describe("Array of team UUIDs to revoke access from"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.delete(`/lists/${id}/teams`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_list_sharing", {
+        title: "Update List Sharing Status",
+        description: "Change a CRM list's sharing visibility. Setting to 'private' also removes all team permissions. " +
+            "Only the list owner can change sharing. Requires lists.share permission. " +
+            "Returns formatted list: {id, name, record_type, sharing, color, count, owner, shared_with_teams, created_at, updated_at}, where record_type is 'company', 'person', 'deal', or a custom object permalink.",
+        inputSchema: {
+            id: z.string().uuid().describe("List ID"),
+            sharing: z.enum(["private", "workspace"]).describe("New sharing visibility"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.patch(`/lists/${id}/sharing`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_notes", {
+        title: "List Notes",
+        description: "Get notes for a CRM record. Each note in the response includes a `records` map, every record (company/person/deal/custom object) the note is currently linked to, plus a `tags` array of any workspace tags attached to the note (each with id, label, color). " +
+            "Every note also carries `type` ('standard' for a note a member wrote, 'meeting' for meeting notes written from a recorded meeting) and `meeting` (null on a standard note; on a meeting note { title, occurred_at, duration_seconds, call_type, ical_uid, attendees, has_transcript, has_recording }, where attendees is [{ email, name }] with name possibly null, call_type is a short category from a fixed list such as 'First founder call' or 'Internal discussion', and duration_seconds / ical_uid / attendees are omitted when unknown). Meeting notes are included only when the API key's user can open the meeting's recording.",
+        inputSchema: {
+            record_id: z.string().uuid().describe("Record ID to list notes for"),
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/notes", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_search_notes", {
+        title: "Search Notes",
+        description: "Search ALL notes in the workspace (unlike List Notes, which needs one record). Combine a free-text title search with a CRM-style filter tree and sort. " +
+            'filters: {"operator":"AND","conditions":[{"field":"tags","operator":"contains_any","value":["<tag_permalink>"]}]}: nested groups supported. ' +
+            "Filterable fields and their operators: title (text: contains/not_contains/starts_with/ends_with/eq/neq/empty/not_empty), " +
+            "created_at (date: before/after/on/empty/not_empty: values accept YYYY-MM-DD or relative periods like \"7 days\", \"3 months ago\", \"2 weeks from now\"), " +
+            "created_by (user id: contains_any/not_contains_any/empty/not_empty), " +
+            "tags (tag permalinks from lighthouse_crm_list_note_tags: contains_any/not_contains_any/contains_all/empty/not_empty), " +
+            "records (linked record ids: contains_any/not_contains_any/contains_all/empty/not_empty; pass a plain array of record ids of ANY type, custom object records included, or an object keyed by record type or custom object permalink {company:[ids],person:[ids],deal:[ids],\"<permalink>\":[ids]}), " +
+            "type (select: contains_any / not_contains_any ONLY, with an array of \"standard\" and / or \"meeting\"; [\"meeting\"] selects meeting notes written from a recorded meeting, [\"standard\"] the notes members wrote; any other value is rejected). " +
+            "An unknown field or invalid operator is rejected with a clear error naming it. " +
+            "Every returned note carries `type` ('standard' | 'meeting') and `meeting` (null on a standard note; on a meeting note { title, occurred_at, duration_seconds, call_type, ical_uid, attendees, has_transcript, has_recording }; attendees is [{ email, name }] with name possibly null; duration_seconds, ical_uid and attendees are omitted when unknown). Meeting notes are included only when the API key's user can open the meeting's recording.",
+        inputSchema: {
+            search: z.string().optional().describe("Free-text search on the note title"),
+            filters: z.record(z.any()).optional().describe("CRM-style filter object for notes (see tool description for fields + operators)"),
+            sort: z.array(z.record(z.any())).optional().describe('Sort array: [{"field":"<key>","direction":"asc"|"desc"}] (default: created_at desc). Sortable fields: title, created_at, created_by. tags, records and type are not sortable.'),
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/notes/search", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_note", {
+        title: "Create Note",
+        description: "Create a note, optionally linked to one or more CRM records. Records are optional: omit them to create a standalone note that still appears in the workspace Notes section. " +
+            "Link records via the `records` param, keyed by type. " +
+            "The company/person/deal ids you pass MUST be EXISTING CRM record ids (the ids returned by lighthouse_crm_* tools), NOT discovery ids from lighthouse_discovery_* search results. To note on a discovery result, first add it to your CRM and use the resulting CRM record id. " +
+            "Content is HTML; plain text works too. " +
+            "To @mention/tag workspace users: " +
+            "1) Call lighthouse_workspace_list_users first to find the user's ID, " +
+            "2) Include their user IDs in tagged_users, " +
+            "3) Include a mention span in the HTML content: " +
+            '<span data-type="mention" data-id="USER_UUID" data-label="First Last">@First Last</span>. ' +
+            "Tagged users receive an in-app notification. " +
+            "Optionally attach workspace tags by permalink via `tags` (list the available tags with lighthouse_crm_list_note_tags); these are labeled, colored tags shared across the workspace and are separate from tagged_users. " +
+            "This always creates a standard note (type 'standard', meeting null): there is no type input (one sent in the request is ignored), and meeting notes are written by the Notetaker from a recording, never through this tool.",
+        inputSchema: {
+            records: z
+                .record(z.array(z.string().uuid()))
+                .optional()
+                .describe("Records to link, keyed by record type. Optional: omit for a standalone note. Any record ids you pass must exist or the call returns a not-found error."),
+            title: z.string().describe("Note title"),
+            content: z.string().describe("Note content (plain text or HTML). Use <p> tags for paragraphs. For @mentions, include mention spans (see description)."),
+            tagged_users: z
+                .array(z.string().uuid())
+                .optional()
+                .describe("Array of workspace user UUIDs to tag/mention in the note. Must match mention spans in content."),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe("Array of workspace tag permalinks to attach to the note (from lighthouse_crm_list_note_tags). Distinct from tagged_users."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/notes", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_note", {
+        title: "Get Note",
+        description: "Get a single note by ID. Response includes a `records` object keyed by record type (or custom object permalink) with every linked record, plus a `tags` array of any workspace tags attached to the note (each with permalink, label, color). " +
+            "`type` is 'standard' for a note a member wrote and 'meeting' for meeting notes written from a recorded meeting; `meeting` is null on a standard note and { title, occurred_at, duration_seconds, call_type, ical_uid, attendees, has_transcript, has_recording } on a meeting note: title and occurred_at come from the meeting itself, attendees is [{ email, name }] with name possibly null, call_type is one of 'First founder call', 'Follow-up founder call', 'Diligence call', 'Re-engagement', 'Portfolio check-in', 'Board meeting', 'Investment committee', 'LP meeting', 'Fundraising call', 'Co-investor or syndication call', 'Internal discussion', 'Hiring or reference call', 'Partnership or vendor call' or 'Other', and duration_seconds / ical_uid / attendees are omitted when unknown. A meeting note is returned only when the API key's user can open the meeting's recording; otherwise it is reported as not found.",
+        inputSchema: {
+            id: z.string().uuid().describe("Note ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/notes/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_note", {
+        title: "Update Note",
+        description: "Change an existing note's title, content, tags or mentions by note ID. Pass only what changes: a key that is absent is left untouched. " +
+            "content REPLACES the whole body: to ADD to a note, read it with lighthouse_crm_get_note first and pass the full new content with the addition, never the addition alone (anything you leave out, an existing @mention span included, is gone). " +
+            "Content is HTML, the same format lighthouse_crm_create_note takes: <p> for paragraphs, <ul><li> for bullets, <h2> for a heading, <strong> for emphasis; plain text works too and is stored as one paragraph. " +
+            "To @mention/tag workspace users: 1) call lighthouse_workspace_list_users to find the user's ID, 2) include their user IDs in tagged_users, 3) include a mention span in the HTML content: " +
+            '<span data-type="mention" data-id="USER_UUID" data-label="First Last">@First Last</span>. ' +
+            "A user newly named in tagged_users receives one in-app notification; keep the spans of people already mentioned when you resend the content. " +
+            "tags are the workspace's labeled, colored note tags (permalinks from lighthouse_crm_list_note_tags), separate from tagged_users: the array REPLACES the tag set (an empty array clears it); to add or remove single tags without touching the rest use lighthouse_crm_manage_note_tags. " +
+            "Works on meeting notes too: the edit is kept on the current version and the note reports it as edited. " +
+            "Returns the updated note in the same shape as lighthouse_crm_get_note. To change which records a note is attached to use lighthouse_crm_link_note_record / lighthouse_crm_unlink_note_record; to remove it use lighthouse_crm_delete_note.",
+        inputSchema: {
+            id: z.string().uuid().describe("Note ID"),
+            title: z.string().optional().describe("New title"),
+            content: z.string().optional().describe("New content, replacing the whole body. HTML (<p> paragraphs, <ul><li> bullets) or plain text. For @mentions include mention spans (see description)."),
+            tags: z.array(z.string()).optional().describe("Workspace tag permalinks to set on the note (from lighthouse_crm_list_note_tags). Replaces the current set; [] clears it. Distinct from tagged_users."),
+            tagged_users: z.array(z.string().uuid()).optional().describe("Workspace user UUIDs to @mention in the note. Must match mention spans in content."),
+        },
+    }, async ({ id, ...changes }) => {
+        try {
+            const res = await api.patch(`/notes/${id}`, changes);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_note", {
+        title: "Delete Note",
+        description: "Permanently delete a note and all of its record links. Meeting notes are deleted the same way, together with every version of them; the meeting's recording and transcript are not affected.",
+        inputSchema: {
+            id: z.string().uuid().describe("Note ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/notes/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_link_note_record", {
+        title: "Link Record to Note",
+        description: "Attach a record to an existing note. Call once per record. " +
+            "The company/person/deal record_id MUST be an EXISTING CRM record id (an id returned by lighthouse_crm_* tools), NOT a discovery id from lighthouse_discovery_* search results. To link a discovery result, first add it to your CRM and use the resulting CRM record id. " +
+            "Use lighthouse_crm_get_note to see the current set of linked records.",
+        inputSchema: {
+            note_id: z.string().uuid().describe("Note ID"),
+            record_type: z.string().describe("Record type: company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Existing CRM record id to link (not a discovery id)"),
+        },
+    }, async ({ note_id, record_type, record_id }) => {
+        try {
+            const res = await api.post(`/notes/${note_id}/records`, { record_type, record_id });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_unlink_note_record", {
+        title: "Unlink Record from Note",
+        description: "Remove a record link from a note. Call once per record. " +
+            "Removing the last linked record is allowed and leaves a standalone note (it stays in the workspace Notes section).",
+        inputSchema: {
+            note_id: z.string().uuid().describe("Note ID"),
+            record_type: z.string().describe("Record type: company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Record ID to unlink"),
+        },
+    }, async ({ note_id, record_type, record_id }) => {
+        try {
+            const res = await api.delete(`/notes/${note_id}/records`, { record_type, record_id });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_note_tags", {
+        title: "List Note Tags",
+        description: "List the workspace's note tags: labeled, colored tags that can be attached to notes as a multi-select. " +
+            "Returns an array of { permalink, label, color }. " +
+            "Use this to find tag permalinks before attaching them to a note (via lighthouse_crm_create_note `tags` or lighthouse_crm_manage_note_tags). " +
+            "These are distinct from tagged_users (user @mentions on a note).",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/note-tags");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_note_tag", {
+        title: "Create Note Tag",
+        description: "Create a new note tag in the workspace vocabulary. The tag can then be attached to notes. " +
+            "Returns the created tag as { permalink, label, color }. " +
+            "Color is an optional palette code (get available colors from lighthouse_crm_get_color_palette); omit it to auto-assign one.",
+        inputSchema: {
+            label: z.string().describe("Tag display label"),
+            color: z.string().optional().describe("Tag color (palette code, auto-assigned if omitted)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/note-tags", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_note_tag", {
+        title: "Update Note Tag",
+        description: "Update a note tag's label and/or color. Only the fields you pass are changed. " +
+            "Returns the updated tag as { permalink, label, color }.",
+        inputSchema: {
+            permalink: z.string().describe("Tag permalink"),
+            label: z.string().optional().describe("New tag display label"),
+            color: z.string().optional().describe("New tag color (palette code)"),
+        },
+    }, async ({ permalink, ...rest }) => {
+        try {
+            const res = await api.patch(`/note-tags/${permalink}`, rest);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_note_tag", {
+        title: "Delete Note Tag",
+        description: "Delete a note tag from the workspace vocabulary. The tag is also detached from any notes it was attached to.",
+        inputSchema: {
+            permalink: z.string().describe("Tag permalink"),
+        },
+    }, async ({ permalink }) => {
+        try {
+            const res = await api.delete(`/note-tags/${permalink}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_manage_note_tags", {
+        title: "Attach or Detach Note Tags",
+        description: "Attach or detach workspace tags on an existing note. Pass operation ADD to attach the tag permalinks, or REMOVE to detach them. " +
+            "Find tag permalinks with lighthouse_crm_list_note_tags. Returns the updated note (including its current `tags`).",
+        inputSchema: {
+            note_id: z.string().uuid().describe("Note ID"),
+            operation: z.enum(["ADD", "REMOVE"]).describe("ADD to attach the tags, REMOVE to detach them"),
+            tags: z.array(z.string()).describe("Tag permalinks to attach or detach"),
+        },
+    }, async ({ note_id, operation, tags }) => {
+        try {
+            const res = operation === "ADD"
+                ? await api.post(`/notes/${note_id}/tags`, { tags })
+                : await api.delete(`/notes/${note_id}/tags`, { tags });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_tasks", {
+        title: "List Tasks",
+        description: "List CRM tasks with optional filtering and sorting. " +
+            'filters (CRM-style): {"operator":"AND","conditions":[{"field":"status","operator":"contains_any","value":["<status_value>"]}]} (status AND priority are option fields whose values are workspace-specific; fetch them with lighthouse_crm_list_options(record_type:\'task\', permalink:\'status\' | \'priority\'), and filter priority with contains_any like status, not with a numeric comparison); ' +
+            'sort: [{"field":"due_date","direction":"asc"}]; ' +
+            "Filterable fields: title, status, priority, due_date, description, assigned_to, records (person/company/deal/custom object permalink), created_by (the teammate who created the task, filtered like any user field), created_at, time_in_status (read-only, a whole number of days in the current status). Tasks have no custom fields: any other field name is refused with a 400.",
+        inputSchema: {
+            filters: z.record(z.any()).optional().describe("CRM filter object for tasks. Filterable fields: title, status, priority, due_date, description, assigned_to, records (person/company/deal/custom object permalink), created_by (the teammate who created the task, filtered like any user field), created_at, time_in_status (read-only, a whole number of days in the current status). Tasks have no custom fields: any other field name is refused with a 400. " + CRM_FILTER_DESCRIPTION),
+            sort: z.array(z.record(z.any())).optional().describe('Task sort array: [{"field":"<key>","direction":"asc"|"desc"}], applied in order (default: due_date asc). ' +
+                "Sortable task fields are title, status, priority, due_date, created_at, created_by, time_in_status (asc = fewest days in the current status first). Tasks have no custom fields. " +
+                "Multi-value fields are NOT sortable (assigned_to is multi_user; records and multi_select fields can't be sorted). " +
+                'An unknown or unsortable sort field is rejected with a clear error (field "x" is not sortable), so pick a sortable field. ' +
+                "status and priority sort by their position in the field's option list, not alphabetically. Priority positions are its magnitude, so ascending on priority is least urgent first and descending puts the urgent work on top."),
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/tasks/search", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_task", {
+        title: "Get Task",
+        description: "Get a single CRM task by ID.",
+        inputSchema: {
+            id: z.string().uuid().describe("Task ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/tasks/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_create_task", {
+        title: "Create Task",
+        description: "Create a CRM task, optionally linked to records and assigned to users. " +
+            "Status values are configured per workspace and are NOT fixed: call lighthouse_crm_list_options with record_type 'task' and permalink 'status' to get the allowed values, then pass the option's value (not its label) in `status`.",
+        inputSchema: {
+            title: z.string().describe("Task title"),
+            description: z.string().optional().describe("Task description"),
+            status: z.string().optional().describe("Task status. Use the option value (not the label) from lighthouse_crm_list_options (record_type 'task', permalink 'status'); valid values are workspace-specific, do not assume any fixed set."),
+            priority: z.string().nullable().optional().describe("Priority option value from lighthouse_crm_list_options (record_type 'task', permalink 'priority'): urgent, high, medium, low or very_low unless this workspace configured its own. Speak to the user in the label, never the value. Send null to clear it."),
+            due_date: z.string().optional().describe("Due date (ISO 8601)"),
+            assigned_to: z
+                .array(z.string().uuid())
+                .optional()
+                .describe("Array of user UUIDs to assign the task to"),
+            records: z
+                .record(z.array(z.string().uuid()))
+                .optional()
+                .describe("Records to link, keyed by type: {company: [ids], person: [ids], deal: [ids], <custom_object_permalink>: [ids]}"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/tasks", { data: params });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_task", {
+        title: "Update Task",
+        description: "Update a CRM task. Provide only fields you want to change. " +
+            "assigned_to replaces all current assignees. records replaces all linked records. " +
+            "Status values are configured per workspace and are NOT fixed: call lighthouse_crm_list_options with record_type 'task' and permalink 'status' to get the allowed values, then pass the option's value (not its label) in `status`.",
+        inputSchema: {
+            id: z.string().uuid().describe("Task ID"),
+            title: z.string().optional(),
+            description: z.string().optional(),
+            status: z.string().optional().describe("Task status. Use the option value (not the label) from lighthouse_crm_list_options (record_type 'task', permalink 'status'); valid values are workspace-specific, do not assume any fixed set."),
+            priority: z.string().nullable().optional().describe("Priority option value from lighthouse_crm_list_options (record_type 'task', permalink 'priority'): urgent, high, medium, low or very_low unless this workspace configured its own. Speak to the user in the label, never the value. Send null to clear it."),
+            due_date: z.string().optional(),
+            assigned_to: z
+                .array(z.string().uuid())
+                .optional()
+                .describe("Array of user UUIDs to assign (replaces current assignees)"),
+            records: z
+                .record(z.array(z.string().uuid()))
+                .optional()
+                .describe("Records to link (replaces current), keyed by type: {company: [ids], person: [ids], deal: [ids], <custom_object_permalink>: [ids]}"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...rest } = params;
+            const res = await api.patch(`/tasks/${id}`, { data: rest });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_task", {
+        title: "Delete Task",
+        description: "Permanently delete a CRM task.",
+        inputSchema: {
+            id: z.string().uuid().describe("Task ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/tasks/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_list_documents", {
+        title: "List Documents",
+        description: "List folders and files at the workspace root, or inside a specific folder. " +
+            "Returns { folders, files, breadcrumb } plus meta.folders_next_cursor / " +
+            "meta.files_next_cursor for cursor-based pagination. Pass those cursors " +
+            "back on the next call to get the next page; null means exhausted. " +
+            "Each row includes my_role ('owner' | 'editor' | 'viewer'), is_owner, " +
+            "owner_name, and shared_with_teams[] (each entry has { team_id, role }).",
+        inputSchema: {
+            folder_id: z.string().uuid().optional().describe("Folder UUID to list contents of (omit for workspace root)"),
+            limit: z.number().int().min(1).max(500).optional().describe("Rows per sub-list (folders, files). Default 200, max 500"),
+            folders_cursor: z.string().optional().describe("Opaque cursor (stringified JSON) from a previous response's meta.folders_next_cursor"),
+            files_cursor: z.string().optional().describe("Opaque cursor (stringified JSON) from a previous response's meta.files_next_cursor"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/v1/documents/folders`, params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_create_folder", {
+        title: "Create Folder",
+        description: "Create a folder. At the workspace root, sharing_status is required. " +
+            "Inside a parent folder, sharing is automatically inherited from the parent.",
+        inputSchema: {
+            name: z.string().describe("Folder name"),
+            parent_folder_id: z.string().uuid().optional().describe("Parent folder UUID, omit for root"),
+            sharing_status: z.enum(["PRIVATE", "WORKSPACE"]).optional().describe("Required at root, ignored inside a parent"),
+            team_ids: z.array(z.string().uuid()).optional().describe("Team UUIDs to grant access when sharing_status=PRIVATE"),
+            role: z.enum(["viewer", "editor"]).optional().describe("Role applied to team_ids grants. Defaults to 'viewer'. Viewer grants on WORKSPACE folders are rejected as redundant."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post(`/v1/documents/folders`, params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_update_folder", {
+        title: "Update Folder",
+        description: "Rename, move, or change sharing on a folder. Editors can rename the folder; only owners can move it, change its sharing, or grant team access. " +
+            "Pass team_ids as the full desired list, anything not in the list is revoked.",
+        inputSchema: {
+            folder_id: z.string().uuid().describe("Folder UUID"),
+            name: z.string().optional().describe("New name"),
+            parent_folder_id: z.string().uuid().optional().describe("New parent folder UUID (owner-only)"),
+            clear_parent: z.boolean().optional().describe("Move to workspace root (owner-only)"),
+            sharing_status: z.enum(["PRIVATE", "WORKSPACE"]).optional().describe("Explicit override (null clears to inherit)"),
+            team_ids: z.array(z.string().uuid()).optional().describe("Desired team grants (replaces existing)"),
+            role: z.enum(["viewer", "editor"]).optional().describe("Role applied to NEW team grants (default viewer). Viewer grants are rejected on WORKSPACE folders as redundant."),
+        },
+    }, async (params) => {
+        try {
+            const { folder_id, ...body } = params;
+            const res = await api.patch(`/v1/documents/folders/${folder_id}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_delete_folder", {
+        title: "Delete Folder",
+        description: "Restricted to the folder owner. Deletes the folder and its entire subtree only when you own every descendant folder and file. If any descendant is owned by another user, the request is rejected (CANNOT_DELETE_OTHERS_CONTENT_IN_FOLDER) and nothing is deleted. Editors on the folder cannot delete it. Irreversible: there is no recycle bin and the underlying stored files are permanently removed.",
+        inputSchema: {
+            folder_id: z.string().uuid().describe("Folder UUID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/v1/documents/folders/${params.folder_id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_link_folder_to_record", {
+        title: "Link Folder to Record",
+        description: "Link a folder to a CRM record, associating the whole folder with the record. The folder then appears on the record (in list_record_documents' `folders`, with its file_count); its individual files are not flattened into the record's direct `files` list.",
+        inputSchema: {
+            folder_id: z.string().uuid().describe("Folder UUID"),
+            record_type: z.string().describe("company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Record UUID"),
+        },
+    }, async (params) => {
+        try {
+            const { folder_id, ...body } = params;
+            const res = await api.post(`/v1/documents/folders/${folder_id}/records`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_unlink_folder_from_record", {
+        title: "Unlink Folder from Record",
+        description: "Remove a folder→record link. Files inside stop appearing on the record's Files tab.",
+        inputSchema: {
+            folder_id: z.string().uuid().describe("Folder UUID"),
+            record_type: z.string().describe("company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Record UUID"),
+        },
+    }, async (params) => {
+        try {
+            const { folder_id, ...body } = params;
+            const res = await api.delete(`/v1/documents/folders/${folder_id}/records`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_upload_file", {
+        title: "Upload File",
+        description: "Reserve a file row and get a signed upload URL: " +
+            "1) call this; 2) POST the file to upload_url as multipart/form-data, first append every key/value " +
+            "from the returned upload_fields, then append the file last under the field name 'file'. " +
+            "Do not set an Authorization header. Max 200MB, enforced by storage (oversized uploads are rejected). " +
+            "The file is confirmed and sized automatically the first time you read it " +
+            "(lighthouse_get_file or a folder listing), no separate finalize step. " +
+            "The URL expires in 30 minutes.",
+        inputSchema: {
+            name: z.string().describe("File name (e.g. 'pitch-deck.pdf')"),
+            content_type: z.string().optional().describe("MIME type (e.g. 'application/pdf')"),
+            folder_id: z.string().uuid().optional().describe("Target folder UUID, omit to upload at workspace root"),
+            sharing_status: z.enum(["PRIVATE", "WORKSPACE"]).optional().describe("Required at root; defaults to inherit inside a folder"),
+            team_ids: z.array(z.string().uuid()).optional().describe("Team UUIDs to grant access when sharing_status=PRIVATE"),
+            role: z.enum(["viewer", "editor"]).optional().describe("Role applied to team_ids grants. Defaults to 'viewer'. Viewer grants on WORKSPACE files are rejected as redundant."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post(`/v1/documents/files/upload-url`, params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_get_file", {
+        title: "Get File",
+        description: "Get file metadata. Response includes my_role ('owner' | 'editor' | 'viewer'), is_owner, owner_name, sharing_status, and shared_with_teams[] (each entry has { team_id, role }). Pass download_url=true to also receive a short-lived signed read URL (expires in 15 minutes).",
+        inputSchema: {
+            file_id: z.string().uuid().describe("File UUID"),
+            download_url: z.boolean().optional().describe("Include a short-lived signed download URL"),
+        },
+    }, async (params) => {
+        try {
+            const { file_id, download_url } = params;
+            const res = await api.get(`/v1/documents/files/${file_id}`, download_url ? { download_url: "1" } : undefined);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_update_file", {
+        title: "Update File",
+        description: "Rename, move, or change sharing on a file. Editors can rename/move-between-folders and delete; only the owner can move to root, change sharing, or grant team access. " +
+            "team_ids replaces the current set when supplied.",
+        inputSchema: {
+            file_id: z.string().uuid().describe("File UUID"),
+            name: z.string().optional().describe("New name"),
+            folder_id: z.string().uuid().optional().describe("New parent folder UUID"),
+            clear_folder: z.boolean().optional().describe("Move to workspace root (owner-only)"),
+            sharing_status: z.enum(["PRIVATE", "WORKSPACE"]).optional().describe("Explicit override (null clears to inherit)"),
+            team_ids: z.array(z.string().uuid()).optional().describe("Desired team grants (replaces existing)"),
+            role: z.enum(["viewer", "editor"]).optional().describe("Role applied to NEW team grants (default viewer). Viewer grants are rejected on WORKSPACE files as redundant."),
+        },
+    }, async (params) => {
+        try {
+            const { file_id, ...body } = params;
+            const res = await api.patch(`/v1/documents/files/${file_id}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_delete_file", {
+        title: "Delete File",
+        description: "Owner or editor (file-level editor OR editor-on-parent-folder) can delete, provided they also have the files.delete workspace permission. Permanently deletes the file and purges the underlying object from storage. Irreversible.",
+        inputSchema: {
+            file_id: z.string().uuid().describe("File UUID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/v1/documents/files/${params.file_id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_link_file_to_record", {
+        title: "Link File to Record",
+        description: "Make a file appear on a CRM record's Files tab.",
+        inputSchema: {
+            file_id: z.string().uuid().describe("File UUID"),
+            record_type: z.string().describe("company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Record UUID"),
+        },
+    }, async (params) => {
+        try {
+            const { file_id, ...body } = params;
+            const res = await api.post(`/v1/documents/files/${file_id}/records`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_unlink_file_from_record", {
+        title: "Unlink File from Record",
+        description: "Remove a file→record link.",
+        inputSchema: {
+            file_id: z.string().uuid().describe("File UUID"),
+            record_type: z.string().describe("company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Record UUID"),
+        },
+    }, async (params) => {
+        try {
+            const { file_id, ...body } = params;
+            const res = await api.delete(`/v1/documents/files/${file_id}/records`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_list_record_documents", {
+        title: "List Record Documents",
+        description: "List folders and files linked to a CRM record. Returns { folders, files }. `files` are files linked DIRECTLY to the record; files that live inside a linked folder are NOT flattened into `files`. A linked folder appears in `folders` with its own file_count, so to read a folder's contents list that folder by its id. " +
+            "Each row includes my_role ('owner' | 'editor' | 'viewer'), is_owner, owner_name, and shared_with_teams[] (each entry has { team_id, role }). " +
+            "Cursor-based pagination via meta.folders_next_cursor / meta.files_next_cursor; pass them back as folders_cursor / files_cursor to fetch the next page.",
+        inputSchema: {
+            record_type: z.string().describe("company, person, deal, or a custom object permalink"),
+            record_id: z.string().uuid().describe("Record UUID"),
+            limit: z.number().int().min(1).max(500).optional().describe("Rows per sub-list. Default 200, max 500"),
+            folders_cursor: z.string().optional().describe("Opaque cursor from a previous meta.folders_next_cursor"),
+            files_cursor: z.string().optional().describe("Opaque cursor from a previous meta.files_next_cursor"),
+        },
+    }, async (params) => {
+        try {
+            const { record_type, record_id, limit, folders_cursor, files_cursor } = params;
+            const query = {};
+            if (limit !== undefined)
+                query.limit = limit;
+            if (folders_cursor)
+                query.folders_cursor = folders_cursor;
+            if (files_cursor)
+                query.files_cursor = files_cursor;
+            const res = await api.get(`/v1/documents/records/${record_type}/${record_id}`, query);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_list_views", {
+        title: "List CRM Views",
+        description: "Get all saved CRM views, or list views scoped to a specific list. " +
+            "Supports built-in types and custom objects. " +
+            "Views store filter/sort configurations that can be loaded in search_records.",
+        inputSchema: {
+            record_type: z.string().optional().describe("Filter by record type: 'company', 'person', 'deal', or a custom object permalink (e.g. 'lp', 'project')"),
+            list_id: z.string().uuid().optional().describe("Filter views by list ID. When provided, returns only views scoped to that list."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/views", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_view", {
+        title: "Update CRM View",
+        description: "Update a saved CRM view or list view's name, filters, sort, or layout. " +
+            "Automatically detects whether it's a CRM view or list view. " +
+            "To change sharing settings, use lighthouse_crm_update_view_sharing instead. " +
+            "Uses CRM filter format, call lighthouse_crm_get_attributes first if modifying filters. " +
+            "A semantic_search condition in the new filters must carry its vector (keep the one the view already has, from lighthouse_crm_get_view, or one copied from the app): this API never builds an embedding from text.",
+        inputSchema: {
+            id: z.string().uuid().describe("View ID"),
+            name: z.string().optional(),
+            filters: z.record(z.unknown()).optional().describe(CRM_FILTER_DESCRIPTION),
+            sort: z.array(z.record(z.unknown())).optional().describe(CRM_SORT_DESCRIPTION),
+            view_type: z.enum(["table", "kanban"]).optional(),
+            grouped_by: z.string().optional().describe("Field key to group by (required for kanban views)"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.patch(`/views/${id}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_get_view", {
+        title: "Get CRM View",
+        description: "Get a single saved CRM view or list view by ID. Automatically detects the view type. The filters come back exactly as saved, a semantic_search condition with its vector included: reuse such a condition verbatim in lighthouse_crm_search_records or lighthouse_crm_get_list_records.",
+        inputSchema: {
+            id: z.string().uuid().describe("View ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/views/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_delete_view", {
+        title: "Delete CRM View",
+        description: "Permanently delete a saved CRM view or list view. Automatically detects the view type.",
+        inputSchema: {
+            id: z.string().uuid().describe("View ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/views/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_workspace_me", {
+        title: "Get Current User",
+        description: "Get the current authenticated user's profile (name, email, role, etc.).",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/users/me");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_workspace_list_users", {
+        title: "List Workspace Users",
+        description: "List users in the workspace. Use this to find user IDs for task assignment, note tagging, or filtering by user. " +
+            "Supports search by name/email.",
+        inputSchema: {
+            search: z.string().optional().describe("Search by name or email"),
+            team_id: z.string().uuid().optional().describe("Filter by team ID"),
+            role_id: z.string().uuid().optional().describe("Filter by role ID"),
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/users", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_workspace_get_user", {
+        title: "Get Workspace User",
+        description: "Get a specific workspace user's profile by ID.",
+        inputSchema: {
+            id: z.string().uuid().describe("User ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/users/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_workspace_list_teams", {
+        title: "List Workspace Teams",
+        description: "List all teams in the workspace.",
+        inputSchema: {
+            limit: z.number().min(1).max(100).default(25),
+            offset: z.number().min(0).default(0),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/teams", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_workspace_get_team", {
+        title: "Get Workspace Team",
+        description: "Get a specific team by ID with its members.",
+        inputSchema: {
+            id: z.string().uuid().describe("Team ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/teams/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_attributes", {
+        title: "Get Discovery Data Fields",
+        description: "Get a lightweight catalog of the DATA FIELDS discovery results carry for companies or people: each field's permalink, label, data_type, links_to, read_only, and has_options. " +
+            "These are OUTPUT/data fields, NOT filter keys. To FILTER a search you MUST use the prefixed company_* / person_* keys listed in the `filters` parameter of the discovery search tools. " +
+            "To keep the response small it does NOT include option values: when a field has has_options=true and you need its allowed values, call lighthouse_discovery_list_options with that permalink (or the dedicated lighthouse_discovery_get_industries / lighthouse_discovery_get_locations / lighthouse_discovery_get_funding_types / lighthouse_discovery_get_tags tools). " +
+            "Calling this is optional and NOT required before searching. These are Lighthouse's global database fields, not your CRM fields.",
+        inputSchema: {
+            type: z
+                .enum(["company", "person"])
+                .optional()
+                .describe("Entity type: 'company' or 'person'. If omitted, returns both as { company: [...], person: [...] }."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/database/attributes", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_list_options", {
+        title: "List Discovery Field Options",
+        description: "Get the allowed values (value, label, color) for a single discovery select / multi_select field. " +
+            "Call this when lighthouse_discovery_get_attributes shows has_options=true for a field and you need its valid values. " +
+            "Results are paginated (max 100 per page): use `search` to narrow by label, and `limit` / `offset` to page through a field with many values (e.g. locations). " +
+            "For the large shared taxonomies you can also use the dedicated tools: get_industries, get_locations, get_funding_types, get_tags.",
+        inputSchema: {
+            record_type: z.enum(["company", "person"]).describe("Entity type the field belongs to"),
+            field_permalink: z.string().describe("Field permalink (from lighthouse_discovery_get_attributes)"),
+            search: z.string().optional().describe("Filter options whose label contains this text (case-insensitive)"),
+            limit: z.number().optional().describe("Max options to return (default 100, max 100)"),
+            offset: z.number().optional().describe("Number of options to skip for pagination (default 0)"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/database/options", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_search_companies", {
+        title: "Search Discovery Companies",
+        description: "Search Lighthouse's global company database to DISCOVER new companies. " +
+            "This searches Lighthouse's enriched database (millions of companies), NOT your CRM. " +
+            "WORKFLOW: 1) Build filters using ONLY the company_* filter keys listed in the `filters` parameter below. " +
+            "Do NOT call lighthouse_discovery_get_attributes for filter keys. It returns the data fields each result carries (e.g. categories, headquarter_country), which are NOT valid filter keys; if used to filter they are dropped and reported in the response's `ignored_filter_fields`. " +
+            "2) For category filters (company_categories, company_sdg_impact), call lighthouse_discovery_get_industries to get valid values. " +
+            "3) For location filters (company_hq_country, company_hq_region, and any other *_country/*_region key), call lighthouse_discovery_get_locations to get country/region codes. " +
+            "4) For investor/past-company/education filters, call lighthouse_discovery_search_entities (record_type 'investor', 'company', or 'school') to resolve names to ids. " +
+            "The COMPLETE, authoritative list of company_* filter keys (every field with its data type and where its values come from) is at the END of the `filters` parameter description below. Read it and use those keys exactly; do not anchor on a subset, invent variants (no _usd suffix), or abbreviate (hq vs headquarter). " +
+            "The response's `meta` includes `total` (the match count, e.g. \"247\", or \"1k+\" when there are 1000+) and `ignored_filter_fields` (any filter key that was NOT recognized, each with a did_you_mean suggestion when a close match can be computed). Check `ignored_filter_fields` to confirm every filter was actually applied.",
+        inputSchema: {
+            filters: z
+                .record(z.unknown())
+                .optional()
+                .describe(DISCOVERY_FILTER_DESCRIPTION + COMPANY_DISCOVERY_FIELDS),
+            sort: z.record(z.unknown()).optional().describe(COMPANY_DISCOVERY_SORT_DESCRIPTION),
+            skip: z.number().min(0).default(0).describe("Number of results to skip"),
+            limit: z.number().min(1).max(100).default(25).describe("Results per page"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/database/search", { record_type: "company", ...params });
+            return text(leanDiscovery(res, "company"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_search_people", {
+        title: "Search Discovery People",
+        description: "Search Lighthouse's global people database to DISCOVER new people. " +
+            "This searches Lighthouse's enriched database, NOT your CRM. " +
+            "WORKFLOW: 1) Build filters using ONLY the person_* filter keys listed in the `filters` parameter below. " +
+            "Do NOT call lighthouse_discovery_get_attributes for filter keys. It returns the data fields each result carries (e.g. country, categories), which are NOT valid filter keys; if used to filter they are dropped and reported in the response's `ignored_filter_fields`. " +
+            "2) For category filters (person_current_categories, person_past_categories), call lighthouse_discovery_get_industries to get valid values. " +
+            "3) For location filters (person_country, person_region, and any other *_country/*_region key), call lighthouse_discovery_get_locations to get country/region codes. " +
+            "4) For past-company/education filters, call lighthouse_discovery_search_entities (record_type 'company' or 'school') to resolve names to ids. " +
+            "The COMPLETE, authoritative list of person_* filter keys (every field with its data type and where its values come from) is at the END of the `filters` parameter description below. Read it and use those keys exactly; do not anchor on a subset, invent variants, or abbreviate. " +
+            "The response's `meta` includes `total` (the match count, e.g. \"247\", or \"1k+\" when there are 1000+) and `ignored_filter_fields` (any filter key that was NOT recognized, each with a did_you_mean suggestion when a close match can be computed). Check `ignored_filter_fields` to confirm every filter was actually applied. " +
+            "People results are returned by founder relevance; custom sorting is NOT supported for people, so there is no sort parameter.",
+        inputSchema: {
+            filters: z
+                .record(z.unknown())
+                .optional()
+                .describe(DISCOVERY_FILTER_DESCRIPTION + PERSON_DISCOVERY_FIELDS),
+            skip: z.number().min(0).default(0).describe("Number of results to skip"),
+            limit: z.number().min(1).max(100).default(25).describe("Results per page"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/mcp/database/search", { record_type: "person", ...params });
+            return text(leanDiscovery(res, "person"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_semantic_search_companies", {
+        title: "Semantic Search Companies",
+        description: "Find companies by MEANING, not exact keywords. Describe the kind of company you are looking for in plain language (what it does, who it serves, its sector, its business model) and Lighthouse returns the most semantically similar companies from its global database (NOT your CRM), ranked by relevance. " +
+            "USE THIS when the request is conceptual or hard to express as exact filters, e.g. 'companies like Stripe but for healthcare', 'startups building developer tools for AI agents', 'sustainable packaging for e-commerce'. " +
+            "You CAN combine it with structured filters: pass `filters` using the same company_* keys as lighthouse_discovery_search_companies and they apply together (semantic match AND your filters), e.g. semantically-similar companies that are ALSO headquartered in Germany. " +
+            "PREFER lighthouse_discovery_search_companies (no `query`) when the user only needs exact attribute filters (a specific country, funding stage, headcount range) with no conceptual component. " +
+            "If the user asks for something this cannot satisfy (an exact field the database does not expose, a guarantee of completeness, or ordering by a specific metric), tell them that plainly and fall back to lighthouse_discovery_search_companies with filters rather than guessing. " +
+            "The response's `meta` includes `total` (the match count, e.g. \"247\", or \"1k+\" when there are 1000+) and `ignored_filter_fields` (any filter key that was NOT recognized, each with a did_you_mean suggestion when a close match can be computed). Check `ignored_filter_fields` to confirm every filter was actually applied. " +
+            "`query` is required; everything else is optional.",
+        inputSchema: {
+            query: z.string().min(1).describe("Plain-language description of the ideal company to match by meaning. Required."),
+            filters: z
+                .record(z.unknown())
+                .optional()
+                .describe("Optional structured filters applied together with the semantic match (AND). " + DISCOVERY_FILTER_DESCRIPTION + COMPANY_DISCOVERY_FIELDS),
+            min_similarity: z
+                .number()
+                .min(0)
+                .max(0.99)
+                .optional()
+                .describe("Optional strictness cutoff (0-1, higher = stricter / fewer results). Defaults to a balanced value."),
+            skip: z.number().min(0).default(0).describe("Number of results to skip"),
+            limit: z.number().min(1).max(100).default(25).describe("Results per page"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/database/semantic-search-companies", params);
+            return text(leanDiscovery(res, "company"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_semantic_search_people", {
+        title: "Semantic Search People",
+        description: "Find people by MEANING, not exact keywords. Describe the ideal person in plain language (their role, skills, the industry they work in, their background) and Lighthouse returns the most semantically similar people from its global database (NOT your CRM), ranked by relevance. " +
+            "USE THIS when the request is conceptual or hard to express as exact filters, e.g. 'technical co-founders who worked on payments infrastructure', 'ex-FAANG ML engineers now in climate tech'. " +
+            "You CAN combine it with structured filters: pass `filters` using the same person_* keys as lighthouse_discovery_search_people and they apply together (semantic match AND your filters), e.g. semantically-similar people who are ALSO based in the UK. " +
+            "PREFER lighthouse_discovery_search_people (no `query`) when the user only needs exact attribute filters with no conceptual component. " +
+            "If the user asks for something this cannot satisfy (an exact field the database does not expose, a guarantee of completeness, or ordering by a specific metric), tell them that plainly and fall back to lighthouse_discovery_search_people with filters rather than guessing. " +
+            "The response's `meta` includes `total` (the match count, e.g. \"247\", or \"1k+\" when there are 1000+) and `ignored_filter_fields` (any filter key that was NOT recognized, each with a did_you_mean suggestion when a close match can be computed). Check `ignored_filter_fields` to confirm every filter was actually applied. " +
+            "`query` is required; everything else is optional.",
+        inputSchema: {
+            query: z.string().min(1).describe("Plain-language description of the ideal person to match by meaning. Required."),
+            filters: z
+                .record(z.unknown())
+                .optional()
+                .describe("Optional structured filters applied together with the semantic match (AND). " + DISCOVERY_FILTER_DESCRIPTION + PERSON_DISCOVERY_FIELDS),
+            min_similarity: z
+                .number()
+                .min(0)
+                .max(0.99)
+                .optional()
+                .describe("Optional strictness cutoff (0-1, higher = stricter / fewer results). Defaults to a balanced value."),
+            skip: z.number().min(0).default(0).describe("Number of results to skip"),
+            limit: z.number().min(1).max(100).default(25).describe("Results per page"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/database/semantic-search-people", params);
+            return text(leanDiscovery(res, "person"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_lookup_by_domain", {
+        title: "Lookup Companies by Domain",
+        description: "Look up companies in Lighthouse's global database by their website domain(s). " +
+            "Returns enriched company profiles for matching domains. Max 1000 domains per request. " +
+            "Each returned profile is condensed (the long growth and workforce history and the activity-signal " +
+            "feed are omitted, and the associated-people list is capped) to keep the response compact; for a " +
+            "single company's full profile call lighthouse_discovery_get_company. " +
+            "Consumes API entity credits for each new company returned.",
+        inputSchema: {
+            domains: z
+                .array(z.string())
+                .describe("Array of domains to look up (e.g. ['google.com', 'stripe.com']). Max 1000."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/database/get-companies-by-domain", params);
+            return text(leanDiscovery(res, "company"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_lookup_by_linkedin", {
+        title: "Lookup Companies by LinkedIn",
+        description: "Look up companies in Lighthouse's global database by LinkedIn URL(s). " +
+            "Returns enriched company profiles for matching LinkedIn company pages. Max 1000 URLs per request. " +
+            "Each returned profile is condensed (the long growth and workforce history and the activity-signal " +
+            "feed are omitted, and the associated-people list is capped) to keep the response compact; for a " +
+            "single company's full profile call lighthouse_discovery_get_company. " +
+            "Consumes API entity credits for each new company returned.",
+        inputSchema: {
+            linkedin_urls: z
+                .array(z.string())
+                .describe("Array of LinkedIn company URLs (e.g. ['https://linkedin.com/company/stripe']). Max 1000."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/database/get-companies-by-linkedin", params);
+            return text(leanDiscovery(res, "company"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_lookup_people_by_linkedin", {
+        title: "Lookup People by LinkedIn",
+        description: "Look up people in Lighthouse's global database by LinkedIn profile URL(s). " +
+            "Returns enriched person profiles for matching LinkedIn pages. Max 1000 URLs per request. " +
+            "Each returned profile is condensed (the activity-signal feed is omitted and the associated-companies " +
+            "and education lists are capped) to keep the response compact; for a single person's full profile call " +
+            "lighthouse_discovery_get_person. " +
+            "Consumes API entity credits for each new person returned.",
+        inputSchema: {
+            linkedin_urls: z
+                .array(z.string())
+                .describe("Array of LinkedIn profile URLs (e.g. ['https://linkedin.com/in/john-doe']). Max 1000."),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/database/get-people-by-linkedin", params);
+            return text(leanDiscovery(res, "person"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_saved_searches", {
+        title: "List Saved Searches",
+        description: "List all saved discovery searches in the workspace. " +
+            "Returns saved searches you own and workspace-shared searches. " +
+            "Each search includes its filters and type (company or person). " +
+            "Use the search ID with lighthouse_discovery_get_search_results to run a saved search.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/database/get-saved-searches");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_search_results", {
+        title: "Get Saved Search Results",
+        description: "Run a saved discovery search and get its results. " +
+            "The search's saved filters are applied automatically. " +
+            "Optionally filter by signal creation date range. " +
+            "Consumes API entity credits for new entities returned.",
+        inputSchema: {
+            search_id: z.string().uuid().describe("Saved search ID (from lighthouse_discovery_get_saved_searches)"),
+            signal_created_after: z.string().optional().describe("Only include results with signals created after this ISO timestamp"),
+            signal_created_before: z.string().optional().describe("Only include results with signals created before this ISO timestamp"),
+            skip: z.number().min(0).default(0).describe("Number of results to skip"),
+            limit: z.number().min(1).max(100).default(25).describe("Results per page"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/database/get-search-results", params);
+            return text(leanDiscovery(res, "auto"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_locations", {
+        title: "Get Location Options",
+        description: "Get available location options (countries and regions) for discovery filters. " +
+            "ALWAYS call this to get valid country/region values before filtering by location fields " +
+            "(company_hq_country, company_hq_region, person_country, person_region, company_investor_country, etc.). " +
+            "Returns {countries: [{name, value, flag}], regions: [{name, value, flag}]}. " +
+            "Use 'value' (alpha-2 codes for countries e.g. 'DE' for Germany, IDs for regions) " +
+            "in filter conditions with contains_any/not_contains_any operators.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/database/get-locations");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_industries", {
+        title: "Get Industry & Category Options",
+        description: "Get available industry and category options for discovery filters. " +
+            "ALWAYS call this to get valid category values before filtering by company_categories, company_sdg_impact, " +
+            "person_current_categories, person_past_categories, person_current_sdg_impact, or person_past_sdg_impact. " +
+            "Returns {categories: [{name, value}], sdg_categories: [{name, value}]}. " +
+            "Categories include sectors like SaaS, B2B, FinTech, HealthTech, etc. " +
+            "Use 'value' (permalink string) in filter conditions with contains_any/not_contains_any/contains_all operators.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/database/get-industries");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_tags", {
+        title: "Get Tag Options",
+        description: "Get the tag options for discovery filters. " +
+            "ALWAYS call this to get valid tag values before filtering by company_tags or person_tags. " +
+            "Returns {company_tags: [{value, name}], person_tags: [{value, name}]}. " +
+            "Use 'value' in filter conditions with contains_any/not_contains_any/contains_all operators.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/database/get-tags");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_funding_types", {
+        title: "Get Funding Type Options",
+        description: "Get the funding round types available for the funding discovery filters " +
+            "(company_last_funding_type, person_company_last_funding_type). " +
+            "Returns an array of {name, label} ordered by stage. " +
+            "Use each option's 'name' (e.g. 'seed', 'series_a') as the filter value with " +
+            "contains_any / not_contains_any operators. " +
+            "The filters also accept the special value 'no_funding' to match companies with no recorded funding round.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/database/get-funding-types");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_search_investors", {
+        title: "Search Investors by Name",
+        description: "Search for investors by name to get their UUIDs for use in discovery filters. " +
+            "Use the returned 'id' values in company_investor filter conditions (investor_multi_select type). " +
+            "Returns [{id, name, avatar_url}]. Pass the id (or [{id, label}] objects) as the filter value. " +
+            "DEPRECATED: use lighthouse_discovery_search_entities with record_type 'investor' instead (better, typo-tolerant ranking). Kept for backward compatibility.",
+        inputSchema: {
+            query: z.string().describe("Investor name to search for (e.g. 'Sequoia', 'a16z')"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/database/search-entities", { type: "investor", query: params.query });
+            return text(leanDiscovery(res, "auto"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_search_organizations", {
+        title: "Search Organizations by Name",
+        description: "Search for organizations (companies) by name to get their UUIDs for use in discovery filters. " +
+            "Use the returned 'id' values in work_experience_multi_select filter conditions " +
+            "(company_team_past_companies, person_past_companies). " +
+            "Returns a THIN identity row [{id, name, avatar_url, domain, short_description, headcount, location, total_funding_amount_usd}]. This is NOT a full company profile. " +
+            "For the complete profile, pass the id to lighthouse_discovery_get_company (or use lighthouse_discovery_get_entity_by_name); do not report a company's details as missing based on this row. " +
+            "DEPRECATED: use lighthouse_discovery_search_entities with record_type 'company' instead (better, typo-tolerant ranking). Kept for backward compatibility.",
+        inputSchema: {
+            query: z.string().describe("Organization name to search for (e.g. 'Google', 'McKinsey')"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/database/search-entities", { type: "organization", query: params.query });
+            return text(leanDiscovery(res, "auto"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_search_schools", {
+        title: "Search Schools by Name",
+        description: "Search for educational institutions by name to get their UUIDs for use in discovery filters. " +
+            "Use the returned 'id' values in education_multi_select filter conditions " +
+            "(company_team_education, person_education). " +
+            "Returns [{id, name, avatar_url}]. " +
+            "DEPRECATED: use lighthouse_discovery_search_entities with record_type 'school' instead (better, typo-tolerant ranking). Kept for backward compatibility.",
+        inputSchema: {
+            query: z.string().describe("Institution name to search for (e.g. 'MIT', 'Stanford', 'Harvard')"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/database/search-entities", { type: "school", query: params.query });
+            return text(leanDiscovery(res, "auto"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_search_entities", {
+        title: "Search Entities (companies, people, investors, schools)",
+        description: "Similarity-ranked, typo-tolerant search across companies, people, investors, and schools. " +
+            "Returns lightweight matches (id, record_type, name, avatar_url, is_discoverable, plus a few " +
+            "disambiguators like domain/employees/location) ranked by relevance then popularity (e.g. " +
+            "searching 'Apple' returns the largest Apple first). " +
+            "Use this to: (a) get an id to drop into a discovery filter (past companies, education, investor " +
+            "filters), or (b) locate an entity before reading its full profile. " +
+            "It searches ALL entities, including ones that do not appear in discovery result lists, so you will " +
+            "always find a match if one exists. If you only need an id for a filter, stop after this call. " +
+            "To read full details, pass the returned id to lighthouse_discovery_get_company (companies) or " +
+            "lighthouse_discovery_get_person (people). " +
+            "is_discoverable means the entity also appears in discovery result lists; when false you can still " +
+            "read its full profile by id, it just will not show up in list/search-results endpoints.",
+        inputSchema: {
+            record_type: z
+                .enum(["company", "person", "investor", "school"])
+                .describe("Which kind of entity to search for"),
+            query: z.string().describe("Name to search for (typo-tolerant, e.g. 'Relay Robotics', 'a16z', 'MIT')"),
+            limit: z.number().int().min(1).max(100).optional().describe("Max results (1-100, default 25)"),
+            offset: z.number().int().min(0).optional().describe("Results to skip for pagination (default 0)"),
+        },
+    }, async (params) => {
+        try {
+            const query = { record_type: params.record_type, query: params.query };
+            if (params.limit !== undefined)
+                query.limit = params.limit;
+            if (params.offset !== undefined)
+                query.offset = params.offset;
+            const res = await api.get("/database/search-entities-v2", query);
+            return text(leanDiscovery(res, "auto"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_company", {
+        title: "Get Company Profile by ID",
+        description: "Returns the profile for a single company by id: firmographics, funding, categories, tags, links, " +
+            "and the first several associated people. " +
+            "To stay within response limits, this returns a condensed view: the long growth and workforce " +
+            "history and the activity-signal feed are omitted, and the associated-people list is capped. " +
+            "Always returns data for an entity that exists, including companies not shown in discovery result " +
+            "lists, so there is no dead-end. " +
+            "Obtain the id from lighthouse_discovery_search_entities (record_type 'company') first. " +
+            "This accepts only a company id (not a person, investor, or school id), and does not search by name.",
+        inputSchema: {
+            id: z.string().describe("The company id (UUID) returned by lighthouse_discovery_search_entities"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/database/company/${encodeURIComponent(params.id)}`);
+            return text(leanDiscovery(res, "company"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_person", {
+        title: "Get Person Profile by ID",
+        description: "Returns the profile for a single person by id: bio, links, founder score, person tags, " +
+            "the first several associated companies / work history, and education. " +
+            "To stay within response limits, this returns a condensed view: the activity-signal feed is omitted, " +
+            "and the associated-companies and education lists are capped. " +
+            "Always returns data for an entity that exists, including people not shown in discovery result lists, " +
+            "so there is no dead-end. " +
+            "Obtain the id from lighthouse_discovery_search_entities (record_type 'person') first. " +
+            "This accepts only a person id, and does not search by name.",
+        inputSchema: {
+            id: z.string().describe("The person id (UUID) returned by lighthouse_discovery_search_entities"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/database/person/${encodeURIComponent(params.id)}`);
+            return text(leanDiscovery(res, "person"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_company_traction", {
+        title: "Get Company Traction History",
+        description: "The traction history of one company in the global database, by company id: the two blocks lighthouse_discovery_get_company omits to stay small. " +
+            "workforce_data is the month-by-month headcount and open-job-post history behind the traction charts (series of { date, value } points, oldest first where present); growth_metrics is a summary per tracked metric (headcount, job posts, web traffic, social following and similar, where recorded): { last_value, change_1m, change_3m, change_6m, change_1y, change_2y, change_3y, change_5y, date_last_value }. " +
+            "WHEN TO USE: \"what was their headcount in March\", \"is this company growing\", \"when did hiring pick up\", \"how has traffic moved this year\": anything about a value over time or a rate of change. The profile tool only carries the current headcount. " +
+            "A null block means nothing is recorded for that company. Same id as lighthouse_discovery_get_company (from lighthouse_discovery_search_entities with record_type 'company').",
+        inputSchema: {
+            id: z.string().describe("The company id (UUID) returned by lighthouse_discovery_search_entities"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/database/company/${encodeURIComponent(params.id)}`);
+            return text(profileSection(res, ["workforce_data", "growth_metrics"]));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_company_signals", {
+        title: "Get Company Signals",
+        description: "The detected events for one company in the global database, by company id: the activity-signal feed lighthouse_discovery_get_company omits. " +
+            "signals is a list of { type, created_at, timeframe, percentage_change }: a funding round, a headcount or traffic jump, a hiring spike and similar, each with when it was detected and, for a change, over which timeframe and by how much. Sort by created_at yourself; the list is not ordered. " +
+            "WHEN TO USE: \"what happened at X recently\", \"did they raise\", \"is headcount spiking\", \"any momentum signals\". For the numbers behind a signal read lighthouse_discovery_get_company_traction. " +
+            "A null or empty list means no events are recorded. Same id as lighthouse_discovery_get_company.",
+        inputSchema: {
+            id: z.string().describe("The company id (UUID) returned by lighthouse_discovery_search_entities"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/database/company/${encodeURIComponent(params.id)}`);
+            return text(profileSection(res, ["signals"]));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_person_signals", {
+        title: "Get Person Signals",
+        description: "The detected events for one person in the global database, by person id: the signal feed lighthouse_discovery_get_person omits. " +
+            "signals is a list of { type, created_at, new_company, domain, org_id }: a new company founded or registered, a stealth period, a departure and similar; org_id is a company id you can pass to lighthouse_discovery_get_company, domain its website. Sort by created_at yourself. " +
+            "WHEN TO USE: \"is this founder starting something new\", \"did they leave their company\", \"any recent moves by X\". For the person's work history use lighthouse_discovery_get_person. " +
+            "A null or empty list means no events are recorded. Same id as lighthouse_discovery_get_person.",
+        inputSchema: {
+            id: z.string().describe("The person id (UUID) returned by lighthouse_discovery_search_entities"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/database/person/${encodeURIComponent(params.id)}`);
+            return text(profileSection(res, ["signals"]));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_discovery_get_entity_by_name", {
+        title: "Get Entity Profile by Name",
+        description: "DEFAULT way to get the COMPLETE profile of ONE company or person when you have its name. " +
+            "Resolves the single best-ranked match and returns its full profile in one call (equivalent to " +
+            "lighthouse_discovery_search_entities followed by lighthouse_discovery_get_company / get_person, combined). " +
+            "For investors and schools it returns the lightweight identity row (there is no deep profile for those). " +
+            "It picks the single top match, so when the name is ambiguous and you want to choose among candidates, " +
+            "use lighthouse_discovery_search_entities instead and pass the chosen id to get_company / get_person. " +
+            "Do NOT build a profile from a search/lookup result row (those are thin identity rows): use this tool, " +
+            "or get_company / get_person with the id.",
+        inputSchema: {
+            record_type: z
+                .enum(["company", "person", "investor", "school"])
+                .describe("Which kind of entity to resolve"),
+            name: z.string().describe("Name to resolve to a single best match"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/database/entity-by-name", { record_type: params.record_type, name: params.name });
+            return text(leanDiscovery(res, "auto"));
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    const WIDGET_CONFIG_DESCRIPTION = "Widget config object. Structure depends on report_type: " +
+        "STANDARD (bar/line/pie/table/kpi): {data_source:'companies'|'deals'|'people' (ALWAYS plural: the in-app report editor only recognizes the plural form) or a custom object permalink (e.g. 'lp'; then ALSO set custom_object_permalink to the same permalink; it is required), report_type:'standard' (always set it explicitly), " +
+        "dimension:{field:'<field_key>', is_custom_field:boolean, time_grouping?:'day'|'week'|'month'|'quarter'|'year'}. REQUIRED for EVERY standard widget INCLUDING kpi (a kpi groups its measure by this dimension); omitting it fails with DIMENSION_REQUIRED. For a line chart the dimension field must be a date/datetime type. " +
+        "measure:{aggregation:'COUNT'|'SUM'|'AVG'|'MIN'|'MAX'|'COUNT_DISTINCT', field:'*'|'<field_key>', is_custom_field:boolean}. Aggregations are UPPERCASE. SUM/AVG/MIN/MAX require a numeric field (number/currency/rating/percentage); COUNT always counts records, so pair it with field:'*' only. Do NOT pair SUM/AVG with a multi-value (multi_select/multi_user/multi_record) dimension or segment (the value would be over-counted); use COUNT there instead. " +
+        "segment_by?:{field:'<field_key>', is_custom_field:boolean} splits each bar into stacked series. It ONLY applies to a bar widget; it is ignored for line/pie/table/kpi. " +
+        "filter?:{operator:'AND'|'OR', conditions:[...], groups:[...]}, " +
+        "date_range?:{type:'relative', relative_period:'all_time'|'last_7_days'|'last_30_days'|'last_90_days'|'this_month'|'last_month'|'this_quarter'|'last_quarter'|'this_year'|'last_year'} " +
+        "OR {type:'absolute', start_date:'YYYY-MM-DD', end_date:'YYYY-MM-DD'}. NOTE: date_range scopes the date FIELD you group by (the x-axis) when the dimension is a date/datetime/datetimez field, so it only makes sense for a date-dimension report; for a non-date dimension it falls back to the record's creation date, so prefer a filter condition instead. " +
+        "included_stages?:['value1','value2'], show_axis_labels?:boolean, show_zeros?:boolean, sort_by_stage_order?:boolean}. " +
+        "INTERACTIONS (person/company data_source only): you can group or segment by an interaction date " +
+        "(first_email_date, last_email_date, first_linkedin_message_date, last_linkedin_message_date, first_meeting_date, last_meeting_date, first_interaction_date, last_interaction_date) " +
+        "or by first_interaction_type/last_interaction_type, all with is_custom_field:false; and you can measure lifetime interaction totals with " +
+        "measure.field:'__ix_count_all__'|'__ix_count_email__'|'__ix_count_linkedin__'|'__ix_count_meeting__' (is_custom_field:false; the aggregation is ignored). " +
+        "FUNNEL: {report_type:'funnel', entity_type:'company'|'deal'|'person' (custom objects are NOT supported for funnel), data_source:'companies'|'deals'|'people' (plural form of entity_type; ALWAYS include it or the widget opens with the wrong data source in the in-app editor), stage_field:'<status field_key>', stage_field_is_custom:boolean (true when stage_field is a custom status field), " +
+        "included_stages?:['stage1','stage2'], date_range?:{...}, filter?:{...} (same format and field support as the standard filter above, including relation fields like list_entries and custom fields; it restricts which records the funnel counts)}. " +
+        "HISTORICAL: {report_type:'stage_changes', entity_type:'company'|'deal'|'person' (custom objects are NOT supported for historical), data_source:'companies'|'deals'|'people' (plural form of entity_type; ALWAYS include it), " +
+        "field_permalink:'<status field_key>', time_grouping?:'day'|'week'|'month'|'quarter'|'year', included_stages?:['stage1','stage2'], date_range?:{...}}. " +
+        "included_stages values must be the option VALUES from lighthouse_crm_get_attributes (not display labels). " +
+        "ALWAYS call lighthouse_crm_get_attributes first to discover valid field keys for dimension, measure, and stage_field.";
+    server.registerTool("lighthouse_reports_list_dashboards", {
+        title: "List Dashboards",
+        description: "List all report dashboards accessible to the current user. " +
+            "Returns dashboards you own, workspace-shared dashboards, and team-shared dashboards. " +
+            "Each dashboard includes: id, name, description, sharing (private/workspace), is_owner, " +
+            "owner {id, first_name, last_name, full_name, avatar_url, email}, widget_count, shared_with_teams, created_at, updated_at.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/dashboards");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_create_dashboard", {
+        title: "Create Dashboard",
+        description: "Create a new report dashboard. Dashboards contain report widgets (charts, tables, KPIs). " +
+            "Requires reports.create permission. Returns the full dashboard object (same format as get dashboard).",
+        inputSchema: {
+            name: z.string().describe("Dashboard name"),
+            description: z.string().optional().describe("Dashboard description"),
+            sharing: z
+                .enum(["private", "workspace"])
+                .default("private")
+                .describe("Visibility: 'private' (only you) or 'workspace' (all members)"),
+            team_ids: z
+                .array(z.string().uuid())
+                .optional()
+                .describe("Team IDs to share this dashboard with"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/dashboards", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_get_dashboard", {
+        title: "Get Dashboard",
+        description: "Get a single dashboard by ID with all its widgets. " +
+            "Returns: id, name, description, sharing, is_owner, owner {id, first_name, last_name, full_name, avatar_url, email}, " +
+            "widget_count, shared_with_teams, widgets [{id, name, widget_type, config, created_at, updated_at}], created_at, updated_at.",
+        inputSchema: {
+            id: z.string().uuid().describe("Dashboard ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/dashboards/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_update_dashboard", {
+        title: "Update Dashboard",
+        description: "Update a dashboard's name, description, or sharing. Only the dashboard owner can update. " +
+            "Returns the full dashboard object (same format as get dashboard).",
+        inputSchema: {
+            id: z.string().uuid().describe("Dashboard ID"),
+            name: z.string().optional().describe("New dashboard name"),
+            description: z.string().optional().describe("New description"),
+            sharing: z.enum(["private", "workspace"]).optional().describe("New visibility setting"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.patch(`/dashboards/${id}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_delete_dashboard", {
+        title: "Delete Dashboard",
+        description: "Permanently delete a dashboard and all its widgets. Only the dashboard owner can delete.",
+        inputSchema: {
+            id: z.string().uuid().describe("Dashboard ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/dashboards/${params.id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_list_widgets", {
+        title: "List Dashboard Widgets",
+        description: "Get all widgets for a dashboard. " +
+            "Each widget includes: id, name, widget_type, config, created_at, updated_at.",
+        inputSchema: {
+            id: z.string().uuid().describe("Dashboard ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/dashboards/${params.id}/widgets`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_create_widget", {
+        title: "Create Report Widget",
+        description: "Create a report widget (chart/table/KPI) on a dashboard. " +
+            "WORKFLOW: 1) Call lighthouse_crm_get_attributes to discover field keys for the entity type, " +
+            "2) Build a config object using those keys, 3) Create the widget. " +
+            "Widget types: bar, line, pie, table, kpi, funnel, area. " +
+            "Report types: standard (aggregate by field), funnel (pipeline conversion), stage_changes (historical transitions). " +
+            "Returns: {id, name, widget_type, config, created_at, updated_at}.",
+        inputSchema: {
+            dashboard_id: z.string().uuid().describe("Dashboard ID to add widget to"),
+            name: z.string().describe("Widget/report name"),
+            widget_type: z
+                .enum(["bar", "line", "pie", "table", "kpi", "funnel", "area"])
+                .describe("Visualization type. For bar/line/pie/table/kpi set config.report_type:'standard' (requires a dimension); for funnel set config.report_type:'funnel' (requires stage_field); historical stage-change reports use config.report_type:'stage_changes' with widget_type bar/line/table. Avoid 'area' (it renders as a line chart; use 'line' instead). config.segment_by only takes effect on a 'bar' widget (it is ignored by line/pie/table/kpi)."),
+            config: z.record(z.unknown()).describe(WIDGET_CONFIG_DESCRIPTION),
+        },
+    }, async (params) => {
+        try {
+            const { dashboard_id, ...body } = params;
+            const res = await api.post(`/dashboards/${dashboard_id}/widgets`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_update_widget", {
+        title: "Rename Report Widget",
+        description: "Rename a report widget. Only the name can be changed, a widget's type and " +
+            "configuration are fixed once created. To change what a widget reports, delete " +
+            "it and create a new one. " +
+            "Returns: {id, name, widget_type, config, created_at, updated_at}.",
+        inputSchema: {
+            dashboard_id: z.string().uuid().describe("Dashboard ID"),
+            widget_id: z.string().uuid().describe("Widget ID"),
+            name: z.string().describe("New widget name"),
+        },
+    }, async (params) => {
+        try {
+            const { dashboard_id, widget_id, ...body } = params;
+            const res = await api.patch(`/dashboards/${dashboard_id}/widgets/${widget_id}`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_delete_widget", {
+        title: "Delete Report Widget",
+        description: "Permanently delete a report widget from a dashboard.",
+        inputSchema: {
+            dashboard_id: z.string().uuid().describe("Dashboard ID"),
+            widget_id: z.string().uuid().describe("Widget ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.delete(`/dashboards/${params.dashboard_id}/widgets/${params.widget_id}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_get_widget_data", {
+        title: "Get Widget Report Data",
+        description: "Fetch the aggregated report data for a specific widget. " +
+            "Returns the computed data based on the widget's config (dimensions, measures, segments, filters). " +
+            "For standard reports: array of {label, value, segment?} rows (label = the grouped dimension value, value = the aggregated measure, segment = present only when segment_by is set). " +
+            "For funnel reports: array of {stage, count} rows. " +
+            "For historical reports: array of {period, from_stage, to_stage, transition_count} rows.",
+        inputSchema: {
+            dashboard_id: z.string().uuid().describe("Dashboard ID"),
+            widget_id: z.string().uuid().describe("Widget ID"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/dashboards/${params.dashboard_id}/widgets/${params.widget_id}/data`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_share_dashboard_with_teams", {
+        title: "Share Dashboard with Teams",
+        description: "Grant team-level access to a dashboard. Only the dashboard owner can share. " +
+            "Use lighthouse_workspace_list_teams to find team IDs first. " +
+            "Requires reports.edit permission.",
+        inputSchema: {
+            id: z.string().uuid().describe("Dashboard ID"),
+            team_ids: z.array(z.string().uuid()).describe("Array of team UUIDs to grant access to"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.post(`/dashboards/${id}/teams`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_reports_revoke_dashboard_from_teams", {
+        title: "Revoke Dashboard Team Access",
+        description: "Revoke team-level access from a dashboard. Only the dashboard owner can revoke. " +
+            "Requires reports.edit permission.",
+        inputSchema: {
+            id: z.string().uuid().describe("Dashboard ID"),
+            team_ids: z.array(z.string().uuid()).describe("Array of team UUIDs to revoke access from"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.delete(`/dashboards/${id}/teams`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_share_view_with_teams", {
+        title: "Share View with Teams",
+        description: "Grant team-level access to a CRM view or list view. Only the view owner can share. " +
+            "Use lighthouse_workspace_list_teams to find team IDs first. " +
+            "Requires views.share permission. " +
+            "Returns formatted view: {id, name, entity_type, view_type, filters, sort, grouped_by, sharing, owner, shared_with_teams, created_at}.",
+        inputSchema: {
+            id: z.string().uuid().describe("View ID"),
+            team_ids: z.array(z.string().uuid()).describe("Array of team UUIDs to grant access to"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.post(`/views/${id}/teams`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_revoke_view_from_teams", {
+        title: "Revoke View Team Access",
+        description: "Revoke team-level access from a CRM view or list view. Only the view owner can revoke. " +
+            "Requires views.share permission. " +
+            "Returns formatted view: {id, name, entity_type, view_type, filters, sort, grouped_by, sharing, owner, shared_with_teams, created_at}.",
+        inputSchema: {
+            id: z.string().uuid().describe("View ID"),
+            team_ids: z.array(z.string().uuid()).describe("Array of team UUIDs to revoke access from"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.delete(`/views/${id}/teams`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_crm_update_view_sharing", {
+        title: "Update View Sharing Status",
+        description: "Change a CRM view or list view's sharing visibility. Setting to 'private' also removes all team permissions. " +
+            "Automatically detects view type. Only the view owner can change sharing. Requires views.share permission. " +
+            "Returns formatted view: {id, name, entity_type, view_type, filters, sort, grouped_by, sharing, owner, shared_with_teams, created_at}.",
+        inputSchema: {
+            id: z.string().uuid().describe("View ID"),
+            sharing: z.enum(["private", "workspace"]).describe("New sharing visibility"),
+        },
+    }, async (params) => {
+        try {
+            const { id, ...body } = params;
+            const res = await api.patch(`/views/${id}/sharing`, body);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_email_accounts", {
+        title: "List Email Accounts",
+        description: "List the email accounts the user can access: their own connected mailbox plus mailboxes other workspace " +
+            "members shared with them. Each account carries `status` (connected | disconnected | pending, where disconnected " +
+            "means the account needs to be reconnected) and `permissions` flags: email_metadata (see subject/snippet), " +
+            "email_view (read full emails), email_send, email_create_draft, calendar_view. " +
+            "Use scope 'me' to get only the user's own account (single object or null). " +
+            "Account ids can be passed as account_id to the message tools to scope them to one mailbox.",
+        inputSchema: {
+            scope: z.enum(["me", "all"]).default("all").describe("'me' = only the user's own account; 'all' = own + shared"),
+        },
+    }, async (params) => {
+        try {
+            const path = params.scope === "me" ? "/inbox/email/accounts/me" : "/inbox/email/accounts";
+            const res = await api.get(path);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_linkedin_accounts", {
+        title: "List LinkedIn Accounts",
+        description: "List the LinkedIn messaging accounts the user can access: their own connected account plus accounts other " +
+            "workspace members shared with them. Each account carries `status` (connected | disconnected | pending) and " +
+            "`permissions` flags: message_view (read messages), message_send. " +
+            "Use scope 'me' to get only the user's own account (single object or null).",
+        inputSchema: {
+            scope: z.enum(["me", "all"]).default("all").describe("'me' = only the user's own account; 'all' = own + shared"),
+        },
+    }, async (params) => {
+        try {
+            const path = params.scope === "me" ? "/inbox/linkedin/accounts/me" : "/inbox/linkedin/accounts";
+            const res = await api.get(path);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_email_conversations", {
+        title: "List Email Conversations",
+        description: "List email conversations across every email account the user can read, newest activity first. Filters are " +
+            "all optional and combinable: record_id + record_type ('company' or 'person' ONLY) for correspondence with " +
+            "a CRM record (person = their email addresses, company = its domains); email / domain / free-text query; " +
+            "account_id; after / before dates; unread. No filters = most recent conversations. Great for due diligence: " +
+            "pull all correspondence with a company via record_id or domain, then read each conversation. " +
+            "Live provider data, so no offset: after/before pick the window and a page continues with cursor = meta.next_cursor (same filters) while meta.has_more is true. Conversation ids " +
+            "are account-specific: read one with lighthouse_inbox_email_conversation, passing the row's account.id. " +
+            "Check meta.accounts for per-account failures.",
+        inputSchema: {
+            record_id: z.string().uuid().optional().describe("CRM record ID (requires record_type)"),
+            record_type: z.enum(["company", "person"]).optional().describe("Type of the CRM record (company or person only)"),
+            email: z.string().optional().describe("Email address to search correspondence with (comma-separate for several)"),
+            domain: z.string().optional().describe("Domain to search correspondence with, e.g. example.com (comma-separate for several)"),
+            query: z.string().optional().describe("Free-text search; combined with record/email/domain it narrows those results"),
+            account_id: z.string().uuid().optional().describe("Only this email account (id from lighthouse_inbox_email_accounts)"),
+            after: z.string().optional().describe("Only conversations active on/after this date (e.g. 2024-01-31)"),
+            before: z.string().optional().describe("Only conversations active on/before this date"),
+            unread: z.boolean().optional().describe("Only conversations with (true) / without (false) unread messages"),
+            limit: z.number().min(1).max(100).default(25).describe("Max conversations returned after merging accounts"),
+            cursor: z.string().optional().describe("meta.next_cursor of the previous page, with the same filters"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/inbox/email/conversations", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_email_conversation", {
+        title: "Get Email Conversation",
+        description: "Read one email conversation: the conversation object plus its full messages, newest first: structured " +
+            "from/to/cc/bcc, attachment metadata, and the HTML body when the user can read full emails on that account " +
+            "(metadata-only access returns subject/snippet and data.limited_access: true). Conversation ids are " +
+            "account-specific: BOTH conversation_id AND account_id (the conversation row's account.id from " +
+            "lighthouse_inbox_email_conversations) are required. Long conversations page with a CURSOR like the other inbox lists: pass meta.next_cursor as cursor while meta.has_more is true. A message with no body answers body: null.",
+        inputSchema: {
+            conversation_id: z.string().describe("Conversation ID from lighthouse_inbox_email_conversations"),
+            account_id: z.string().uuid().describe("Required: the email account holding the conversation (row's account.id)"),
+            limit: z.number().min(1).max(100).default(15).describe("Max messages per page. Bodies are full HTML and can be large, so raise this deliberately"),
+            cursor: z.string().optional().describe("meta.next_cursor of the previous page, to fetch the next page of a long conversation"),
+        },
+    }, async (params) => {
+        try {
+            const { conversation_id, ...rest } = params;
+            const res = await api.get(`/inbox/email/conversations/${encodeURIComponent(conversation_id)}`, rest);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_email_create_draft", {
+        title: "Create Email Draft",
+        description: "Save an email draft in one of the user's mailboxes. The draft is NOT sent: it lands in the mailbox for the " +
+            "user to review, edit and send themselves, and there is no tool that can send it. Use this to prepare a reply " +
+            "or a new email on the user's behalf. account_id is REQUIRED (from lighthouse_inbox_email_accounts) and must " +
+            "be an account whose permissions include email_create_draft. At least one recipient is required across to, cc " +
+            "and bcc. To draft a reply, pass reply_to_message_id (a MESSAGE id from lighthouse_inbox_email_conversation, " +
+            "not a conversation id) plus conversation_id, and set the recipients explicitly: a reply does not inherit them. " +
+            "body is HTML. Attachments are not supported here; use the REST API for those. " +
+            "Returns the saved draft: {id, conversation_id, reply_to_message_id, date, subject, body, from, to, cc, bcc, " +
+            "attachments, account}.",
+        inputSchema: {
+            account_id: z.string().uuid().describe("Required: the mailbox to save the draft in (id from lighthouse_inbox_email_accounts)"),
+            to: z.array(z.string()).optional().describe("Recipient email addresses"),
+            cc: z.array(z.string()).optional().describe("Cc email addresses"),
+            bcc: z.array(z.string()).optional().describe("Bcc email addresses"),
+            subject: z.string().optional().describe("Subject line"),
+            body: z.string().optional().describe("Message body as HTML"),
+            conversation_id: z.string().optional().describe("Save the draft inside this existing conversation (id from lighthouse_inbox_email_conversations)"),
+            reply_to_message_id: z.string().optional().describe("Message id this draft replies to, from lighthouse_inbox_email_conversation. Required for the reply to thread correctly"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.post("/inbox/email/drafts", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_linkedin_chats", {
+        title: "List LinkedIn Chats",
+        description: "List LinkedIn conversations across every LinkedIn account the user can view, newest activity first, " +
+            "paginated. Filters are all optional and combinable: record_id + record_type ('company' or 'person' ONLY, where a " +
+            "company matches its team members and company page), person_linkedin / company_linkedin (LinkedIn URL or " +
+            "slug), account_id, unread, and a free-text query on conversation/participant names. Each chat carries " +
+            "attendees, last_message, unread_count, and the account it lives in. Use " +
+            "lighthouse_inbox_linkedin_chat_messages with a chat id to read a conversation. Great for due diligence: " +
+            "filter chats by record_id or company_linkedin, then read each conversation.",
+        inputSchema: {
+            record_id: z.string().uuid().optional().describe("CRM record ID (requires record_type)"),
+            record_type: z.enum(["company", "person"]).optional().describe("Type of the CRM record (company or person only)"),
+            person_linkedin: z.string().optional().describe("Person LinkedIn URL or slug, e.g. https://linkedin.com/in/username"),
+            company_linkedin: z.string().optional().describe("Company LinkedIn URL or slug, e.g. https://linkedin.com/company/acme"),
+            account_id: z.string().uuid().optional().describe("Only this LinkedIn account (id from lighthouse_inbox_linkedin_accounts)"),
+            unread: z.boolean().optional().describe("Only chats with (true) / without (false) unread messages"),
+            query: z.string().optional().describe("Text search on conversation and participant names"),
+            limit: z.number().min(1).max(100).default(25).describe("Conversations per page"),
+            offset: z.number().min(0).default(0).describe("Conversations to skip for pagination"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/inbox/linkedin/chats", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_linkedin_chat_messages", {
+        title: "Get LinkedIn Chat Messages",
+        description: "Read one LinkedIn conversation: returns the chat object (attendees, account) plus its messages (full text, " +
+            "InMail subject, attachment metadata), newest first, paginated, with optional after/before date bounds. " +
+            "Get chat ids from lighthouse_inbox_linkedin_chats.",
+        inputSchema: {
+            chat_id: z.string().describe("Chat ID from lighthouse_inbox_linkedin_chats"),
+            after: z.string().optional().describe("Only messages on/after this date (e.g. 2024-01-31)"),
+            before: z.string().optional().describe("Only messages on/before this date"),
+            limit: z.number().min(1).max(100).default(25).describe("Messages per page"),
+            offset: z.number().min(0).default(0).describe("Messages to skip for pagination"),
+        },
+    }, async (params) => {
+        try {
+            const { chat_id, ...rest } = params;
+            const res = await api.get(`/inbox/linkedin/chats/${encodeURIComponent(chat_id)}/messages`, rest);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_calendar_accounts", {
+        title: "List Calendar Accounts",
+        description: "Calendars the API key's user can read: their own connected calendar (is_own true) and colleagues' calendars shared with them, each with id, email, provider, status, owner and permissions { calendar_view }. " +
+            "A calendar is the same connected account as a mailbox, behind its own sharing switch, so a mailbox shared for mail only is NOT listed here. " +
+            "Use it to know whose meetings lighthouse_inbox_calendar_meetings can see, or to get an account_id to narrow that tool to one calendar. Returns [] when no calendar is connected.",
+        inputSchema: {},
+    }, async () => {
+        try {
+            const res = await api.get("/inbox/calendar/accounts");
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_calendar_meetings", {
+        title: "List Meetings",
+        description: "Calendar meetings across every calendar the API key's user can read (their own, plus colleagues' calendars shared with them), read live from the calendar. PAST meetings newest first by default (the last 6 months; pass months up to 36, or after / before, to move the window), or the SCHEDULED ones soonest first with upcoming=true (90 days ahead by default; an explicit before reaches further). " +
+            "Narrow by CRM record (record_id + record_type, company or person: the record's addresses and domains are matched), by email / domain lists (comma-separated), by words in the meeting TITLE (query; never the notes), or by one calendar (account_id from lighthouse_inbox_calendar_accounts). No filter lists the user's whole calendar over the window. " +
+            "WHEN TO USE: \"when did we last meet X\", \"what meetings do I have next week\", \"have we talked to anyone at acme.com\", \"which calls with this company were recorded\". To find what was DISCUSSED about a topic, list the meetings and read the notes of the likely ones. " +
+            "Each row: id, meeting_key (only when the meeting was recorded), title, description, location, start, end, is_all_day, is_recurring (a recurring meeting appears once per occurrence), status, meeting_link, organizer { name, email }, attendees [{ name, email, response_status }] (response_status is accepted | declined | tentative | needs_action; a missing title, description, location, name or email is null, never an empty string), account { id, email, is_own } (the calendar it was read from) and recording: null when not recorded, else { has_recording, has_transcript, has_notes, duration_seconds, language, recorded_by }. " +
+            "A row with meeting_key is a recorded meeting: pass it to lighthouse_inbox_calendar_meeting_notes for what was discussed and decided, or lighthouse_inbox_calendar_meeting_transcript for what was said. " +
+            "Paged with a CURSOR: pass meta.next_cursor as cursor (same filters) while meta.has_more is true; the window is walked from its near end in 30-day steps, so the first page always holds the newest (or soonest) meetings. meta.complete false means a step could not be fully scanned in time: filter by record, email or domain, or narrow the window. meta.note explains an empty result (no calendar connected, a record with no addresses).",
+        inputSchema: {
+            record_id: z.string().uuid().optional().describe("Meetings with this CRM record's people (requires record_type)"),
+            record_type: z.enum(["company", "person"]).optional().describe("The record's type (requires record_id)"),
+            email: z.string().optional().describe("Comma-separated attendee email addresses to match"),
+            domain: z.string().optional().describe("Comma-separated attendee domains to match (e.g. acme.com)"),
+            query: z.string().optional().describe("Words to match in the meeting title"),
+            account_id: z.string().uuid().optional().describe("Only this calendar (id from lighthouse_inbox_calendar_accounts)"),
+            after: z.string().optional().describe("Only meetings on/after this date (YYYY-MM-DD)"),
+            before: z.string().optional().describe("Only meetings on/before this date (YYYY-MM-DD); with upcoming=true it extends the reach past the 90-day default"),
+            months: z.number().min(1).max(36).optional().describe("How many months back to look when after is not given (default 6, max 36)"),
+            upcoming: z.boolean().optional().describe("true: scheduled meetings from now on, soonest first, instead of past ones"),
+            limit: z.number().min(1).max(100).default(25).describe("Meetings per page"),
+            cursor: z.string().optional().describe("meta.next_cursor of the previous page, with the same filters"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get("/inbox/calendar/meetings", params);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_calendar_meeting", {
+        title: "Get Recorded Meeting",
+        description: "One recorded meeting's metadata by meeting_key (from lighthouse_inbox_calendar_meetings, or the meeting object of a meeting note): title, occurred_at, duration_seconds, language, recorded_by, has_recording, has_transcript, has_notes, and notes { note_id, status, created_at } when meeting notes exist (status ready means readable; processing means they are still being written). " +
+            "WHEN TO USE: to check whether a transcript or notes exist before reading them, or to answer how long a call lasted. It never returns the transcript or the notes themselves. Not found when the meeting was not recorded or the API key's user cannot open its recording.",
+        inputSchema: {
+            meeting_key: z.string().describe("The meeting_key of a recorded meeting"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/inbox/calendar/meetings/${encodeURIComponent(params.meeting_key)}`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_calendar_meeting_notes", {
+        title: "Get Meeting Notes",
+        description: "The meeting notes written from one recorded meeting, by meeting_key: the note in the same shape as lighthouse_crm_get_note (type 'meeting', with the meeting object and the records it is linked to), plus content_markdown (what was generated: Meeting Context first, then the sections) and edited (true when a member changed the note since, in which case content is the version to trust). " +
+            "WHEN TO USE: the user asks what was discussed, decided or agreed in a specific meeting, the next steps from a call, or who attended. Lighter than the transcript: prefer it unless the answer depends on exactly what was said. " +
+            "Not found when the meeting has no notes yet (see has_notes on the meeting) or the API key's user cannot open its recording.",
+        inputSchema: {
+            meeting_key: z.string().describe("The meeting_key of a recorded meeting"),
+        },
+    }, async (params) => {
+        try {
+            const res = await api.get(`/inbox/calendar/meetings/${encodeURIComponent(params.meeting_key)}/notes`);
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    server.registerTool("lighthouse_inbox_calendar_meeting_transcript", {
+        title: "Get Meeting Transcript",
+        description: "The transcript of one recorded meeting by meeting_key, as text: one \"Speaker: text\" line per utterance, in order. " +
+            "WHEN TO USE: only when the answer depends on what was actually SAID (an exact quote, a number, who said what, a nuance the notes would flatten). For what was discussed or decided, lighthouse_inbox_calendar_meeting_notes is enough and far smaller. " +
+            `A long meeting comes back in windows of max_chars (default ${TRANSCRIPT_WINDOW_CHARS}): meta.has_more true means the meeting continues past this window, so pass meta.next_offset_chars as offset_chars to read on, and never treat a window with has_more as the end of the meeting. ` +
+            "Not found when the meeting has no transcript or the API key's user cannot open its recording.",
+        inputSchema: {
+            meeting_key: z.string().describe("The meeting_key of a recorded meeting"),
+            offset_chars: z.number().min(0).default(0).describe("Character offset to start from (meta.next_offset_chars of the previous window)"),
+            max_chars: z.number().min(1).default(TRANSCRIPT_WINDOW_CHARS).describe("Characters per window"),
+        },
+    }, async ({ meeting_key, offset_chars, max_chars }) => {
+        try {
+            const res = await api.get(`/inbox/calendar/meetings/${encodeURIComponent(meeting_key)}/transcript`, { offset_chars, max_chars });
+            return text(res);
+        }
+        catch (e) {
+            return err(`Failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
+    return server;
+}