@sellable/mcp 0.1.318 → 0.1.319

package/dist/tools/linkedin.js

@@ -47,7 +47,7 @@ export const linkedinToolDefinitions = [
     },
     {
         name: "fetch_linkedin_profile",
-        description: "Fetch LinkedIn profile details. Defaults to the cheaper 'main' payload — same envelope shape with most-recent role, headline, about, location, education, top skills, certifications, languages, projects, etc. Pass full=true ONLY when you need the long-tail experience history (positions 6+) or complete skill list (skills 3+) for deep research. Most personalization, qualification, and outreach use cases work with main; reach for full only when the user explicitly asks for full work history or comprehensive skill audit.",
+        description: "Fetch LinkedIn profile details. Defaults to compact context (fetchMinimal=true) that strips images/media/provider metadata and returns identity, headline, about, current role, company, limited experience, education, skills, certifications, languages, and projects. Pass fetchMinimal=false only when you need raw provider fields or media URLs. Pass full=true ONLY when you need the long-tail experience history (positions 6+) or complete skill list (skills 3+) for deep research; full still returns compact output unless fetchMinimal=false.",
         inputSchema: {
             type: "object",
             properties: {
@@ -60,6 +60,11 @@ export const linkedinToolDefinitions = [
                     description: "Opt into the full payload (~38% more expensive, slightly slower). Set true only when you specifically need the long-tail experience history or full skill list. Default false (main payload).",
                     default: false,
                 },
+                fetchMinimal: {
+                    type: "boolean",
+                    description: "Return compact agent context by stripping images/media/provider metadata and limiting long lists. Default true. Set false only when raw provider fields or media URLs are needed.",
+                    default: true,
+                },
             },
             required: ["linkedinUrl"],
         },
@@ -187,6 +192,348 @@ function collectImageUrls(value, urls = new Set()) {
 function pickString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function pickRecord(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (isRecord(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function pickStringFrom(value, keys, maxLength = 1200) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        const picked = typeof candidate === "string" || typeof candidate === "number"
+            ? compactString(candidate, maxLength)
+            : undefined;
+        if (picked)
+            return picked;
+    }
+    return undefined;
+}
+function pickNumberFrom(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (typeof candidate === "number" && Number.isFinite(candidate)) {
+            return candidate;
+        }
+        if (typeof candidate === "string" && candidate.trim()) {
+            const parsed = Number(candidate.replace(/,/g, ""));
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function pickBooleanFrom(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (typeof candidate === "boolean")
+            return candidate;
+    }
+    return undefined;
+}
+function compactString(value, maxLength = 1200) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return undefined;
+    }
+    const compacted = String(value)
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!compacted)
+        return undefined;
+    return compacted.length > maxLength
+        ? `${compacted.slice(0, maxLength - 3).trim()}...`
+        : compacted;
+}
+function stripEmpty(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => stripEmpty(item))
+            .filter((item) => {
+            if (item == null)
+                return false;
+            if (Array.isArray(item))
+                return item.length > 0;
+            if (isRecord(item))
+                return Object.keys(item).length > 0;
+            return true;
+        });
+    }
+    if (!isRecord(value))
+        return value;
+    const entries = Object.entries(value)
+        .map(([key, item]) => [key, stripEmpty(item)])
+        .filter(([, item]) => {
+        if (item == null || item === "")
+            return false;
+        if (Array.isArray(item))
+            return item.length > 0;
+        if (isRecord(item))
+            return Object.keys(item).length > 0;
+        return true;
+    });
+    return Object.fromEntries(entries);
+}
+function asArray(value) {
+    if (Array.isArray(value))
+        return value;
+    return value == null ? [] : [value];
+}
+function pickProfileArray(profile, keys) {
+    for (const key of keys) {
+        const value = profile[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function datePartText(value) {
+    if (typeof value === "string")
+        return compactString(value, 80);
+    if (!isRecord(value))
+        return undefined;
+    const text = pickStringFrom(value, ["text", "date"], 80);
+    if (text)
+        return text;
+    const year = pickNumberFrom(value, ["year"]);
+    const month = pickStringFrom(value, ["month"], 20) || pickNumberFrom(value, ["month"]);
+    if (!year)
+        return undefined;
+    return month ? `${month} ${year}` : String(year);
+}
+function dateRangeFromItem(item) {
+    const explicit = pickStringFrom(item, ["dateRange", "date_range", "period"], 120);
+    if (explicit)
+        return explicit;
+    const startText = datePartText(item.startDate) ||
+        datePartText(stripEmpty({
+            month: item.start_month ?? item.startMonth,
+            year: item.start_year ?? item.startYear,
+        }));
+    const endText = datePartText(item.endDate) ||
+        datePartText(stripEmpty({
+            month: item.end_month ?? item.endMonth,
+            year: item.end_year ?? item.endYear,
+        }));
+    return [startText, endText].filter(Boolean).join(" - ") || undefined;
+}
+function compactExperienceItem(value) {
+    if (!isRecord(value))
+        return {};
+    const companyRecord = pickRecord(value, ["company"]);
+    return stripEmpty({
+        title: pickStringFrom(value, ["title", "position", "job_title"], 160),
+        companyName: pickStringFrom(value, ["companyName", "company_name", "company"], 160) ||
+            pickStringFrom(companyRecord, ["name"], 160),
+        companyLinkedinUrl: pickStringFrom(value, [
+            "companyLinkedinUrl",
+            "companyLinkedInUrl",
+            "company_linkedin_url",
+            "companyLink",
+            "company_public_url",
+        ], 240),
+        dateRange: dateRangeFromItem(value),
+        duration: pickStringFrom(value, ["duration", "current_job_duration"], 80),
+        location: pickStringFrom(value, ["location"], 180),
+        description: pickStringFrom(value, ["description", "summary"], 700),
+        isCurrent: pickBooleanFrom(value, ["isCurrent", "is_current"]),
+    });
+}
+function compactEducationItem(value) {
+    if (!isRecord(value))
+        return {};
+    return stripEmpty({
+        schoolName: pickStringFrom(value, ["schoolName", "school_name", "school"], 180),
+        schoolLinkedinUrl: pickStringFrom(value, ["schoolLinkedinUrl", "schoolLinkedInUrl", "school_linkedin_url"], 240),
+        degree: pickStringFrom(value, ["degree"], 180),
+        fieldOfStudy: pickStringFrom(value, ["fieldOfStudy", "field_of_study"], 180),
+        dateRange: dateRangeFromItem(value),
+    });
+}
+function compactStringList(value, limit) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string" || typeof item === "number") {
+            return compactString(item, 120);
+        }
+        return pickStringFrom(item, ["name", "title", "skill"], 120);
+    })
+        .filter((item) => Boolean(item))
+        .slice(0, limit);
+}
+function compactLanguages(value) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string")
+            return { name: compactString(item, 80) };
+        if (!isRecord(item))
+            return {};
+        return stripEmpty({
+            name: pickStringFrom(item, ["name", "language"], 80),
+            proficiency: pickStringFrom(item, ["proficiency"], 120),
+        });
+    })
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 10);
+}
+function compactNamedItems(value) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string")
+            return { name: compactString(item, 160) };
+        if (!isRecord(item))
+            return {};
+        return stripEmpty({
+            name: pickStringFrom(item, ["name", "title"], 180),
+            organization: pickStringFrom(item, ["organization", "authority", "issuer", "companyName"], 180),
+            dateRange: dateRangeFromItem(item),
+            description: pickStringFrom(item, ["description"], 500),
+            url: pickStringFrom(item, ["url", "link"], 240),
+        });
+    })
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 5);
+}
+function firstCurrentRole(profile) {
+    const current = pickProfileArray(profile, [
+        "currentPosition",
+        "current_position",
+    ])
+        .map(compactExperienceItem)
+        .find((item) => Object.keys(item).length > 0);
+    if (current)
+        return current;
+    const firstExperience = pickProfileArray(profile, [
+        "experience",
+        "experiences",
+    ])
+        .map(compactExperienceItem)
+        .find((item) => Object.keys(item).length > 0);
+    if (firstExperience)
+        return firstExperience;
+    return stripEmpty({
+        title: pickStringFrom(profile, ["job_title", "jobTitle", "title"], 160),
+        companyName: pickStringFrom(profile, ["company", "companyName"], 160),
+        dateRange: dateRangeFromItem(stripEmpty({
+            start_month: profile.current_company_join_month ?? profile.currentCompanyJoinMonth,
+            start_year: profile.current_company_join_year ?? profile.currentCompanyJoinYear,
+        })),
+        duration: pickStringFrom(profile, ["current_job_duration", "currentJobDuration"], 80),
+    });
+}
+function compactCompanyFromProfile(profile, currentRole) {
+    return stripEmpty({
+        name: pickStringFrom(profile, ["company", "companyName"], 180) ||
+            currentRole.companyName,
+        linkedinUrl: pickStringFrom(profile, [
+            "company_linkedin_url",
+            "companyLinkedinUrl",
+            "companyLinkedInUrl",
+            "currentCompanyLinkedinUrl",
+        ], 240) || currentRole.companyLinkedinUrl,
+        website: pickStringFrom(profile, ["company_website", "companyWebsite", "website"], 240),
+        domain: pickStringFrom(profile, ["company_domain", "companyDomain", "currentCompanyDomain"], 120),
+        industry: pickStringFrom(profile, ["company_industry", "industry"], 160),
+        employeeCount: pickNumberFrom(profile, [
+            "company_employee_count",
+            "companyEmployeeCount",
+            "employeeCount",
+        ]),
+        employeeRange: pickStringFrom(profile, ["company_employee_range", "companyEmployeeRange", "employeeCountRange"], 80),
+        description: pickStringFrom(profile, ["company_description", "companyDescription"], 700),
+        founded: pickStringFrom(profile, ["company_year_founded", "founded"], 80) ||
+            pickNumberFrom(profile, ["company_year_founded", "founded"]),
+    });
+}
+export function compactLinkedInProfile(profile) {
+    if (!isRecord(profile))
+        return {};
+    const currentRole = firstCurrentRole(profile);
+    const experience = pickProfileArray(profile, ["experience", "experiences"])
+        .map(compactExperienceItem)
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 5);
+    const education = pickProfileArray(profile, ["education", "educations"])
+        .map(compactEducationItem)
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 3);
+    const skills = compactStringList(profile.topSkills ?? profile.skills, 12);
+    return stripEmpty({
+        id: pickStringFrom(profile, ["id", "profile_id"], 180),
+        publicIdentifier: pickStringFrom(profile, ["publicIdentifier", "public_id", "publicIdentifier"], 120),
+        linkedinUrl: pickStringFrom(profile, ["linkedinUrl", "linkedin_url", "profile_url"], 240),
+        firstName: pickStringFrom(profile, ["firstName", "first_name"], 120),
+        lastName: pickStringFrom(profile, ["lastName", "last_name"], 120),
+        fullName: pickStringFrom(profile, ["fullName", "full_name", "name"], 180) ||
+            [
+                pickStringFrom(profile, ["firstName", "first_name"], 120),
+                pickStringFrom(profile, ["lastName", "last_name"], 120),
+            ]
+                .filter(Boolean)
+                .join(" "),
+        headline: pickStringFrom(profile, ["headline"], 320),
+        about: pickStringFrom(profile, ["about", "summary"], 1600),
+        location: pickStringFrom(profile, ["location"], 180),
+        followerCount: pickNumberFrom(profile, ["followerCount", "follower_count"]),
+        connectionCount: pickNumberFrom(profile, [
+            "connectionsCount",
+            "connection_count",
+            "connectionCount",
+        ]),
+        isPremium: pickBooleanFrom(profile, ["premium", "is_premium", "isPremium"]),
+        isCreator: pickBooleanFrom(profile, ["is_creator", "isCreator"]),
+        isVerified: pickBooleanFrom(profile, [
+            "verified",
+            "is_verified",
+            "isVerified",
+        ]),
+        currentRole,
+        company: compactCompanyFromProfile(profile, currentRole),
+        experience,
+        education,
+        skills,
+        languages: compactLanguages(profile.languages),
+        certifications: compactNamedItems(profile.certifications),
+        projects: compactNamedItems(profile.projects),
+    });
+}
+function canonicalizeLinkedInProfileResponse(raw) {
+    if (raw &&
+        typeof raw === "object" &&
+        raw.status === "success" &&
+        (raw.data || raw.person || raw.profile?.person)) {
+        const canonical = raw.data ?? raw.person ?? raw.profile?.person;
+        const { status, data, person, profile, ...rest } = raw;
+        return { status, profile: canonical, ...rest };
+    }
+    return raw;
+}
+function compactLinkedInProfileResponse(raw) {
+    const normalized = canonicalizeLinkedInProfileResponse(raw);
+    if (normalized &&
+        typeof normalized === "object" &&
+        normalized.status === "success" &&
+        normalized.profile) {
+        return {
+            status: normalized.status,
+            profile: compactLinkedInProfile(normalized.profile),
+        };
+    }
+    return normalized;
+}
 function serializePostMedia(post) {
     const media = post.media && typeof post.media === "object"
         ? post.media
@@ -295,23 +642,9 @@ export async function fetchLinkedInProfile(linkedinUrl, options = {}) {
         params.set("full", "true");
     }
     const raw = await api.get(`/api/v1/scrape/linkedin/profile?${params.toString()}`);
-    // Server returns the same profile object triplicated as `.data`,
-    // `.person`, AND `.profile.person` for backwards-compat with web
-    // callers (signal-discovery, profile-enrichment, canonical-cache, etc).
-    // For the MCP layer, that ~3xs the JSON size and routinely breaches
-    // Claude Code's max-token cap on tool results — which triggers the
-    // harness's "save to file + read in chunks via python3" overflow
-    // fallback. Strip the duplicates here so the agent gets one clean
-    // copy of the data under a single `profile` key.
-    if (raw &&
-        typeof raw === "object" &&
-        raw.status === "success" &&
-        (raw.data || raw.person || raw.profile?.person)) {
-        const canonical = raw.data ?? raw.person ?? raw.profile?.person;
-        const { status, data, person, profile, ...rest } = raw;
-        return { status, profile: canonical, ...rest };
-    }
-    return raw;
+    return options.fetchMinimal === false
+        ? canonicalizeLinkedInProfileResponse(raw)
+        : compactLinkedInProfileResponse(raw);
 }
 export async function fetchCompany(companyUrl) {
     const api = getApi();

package/dist/tools/readiness.js

@@ -20,6 +20,23 @@ function normalizeLeadSourceProvider(provider) {
         return "csv-linkedin";
     return undefined;
 }
+function isPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function hasSignalDiscoveryProgressEvidence(rowCount, importProgress) {
+    const phase = importProgress?.phase ?? null;
+    return (rowCount > 0 ||
+        isPositiveNumber(importProgress?.processed) ||
+        isPositiveNumber(importProgress?.leadsImported) ||
+        isPositiveNumber(importProgress?.scrapedEngagers) ||
+        isPositiveNumber(importProgress?.evaluatedEngagers) ||
+        isPositiveNumber(importProgress?.evaluationTotal) ||
+        isPositiveNumber(importProgress?.activeEvaluationBatches) ||
+        isPositiveNumber(importProgress?.queuedForEvaluation) ||
+        isPositiveNumber(importProgress?.postsScraped) ||
+        phase === "scraping" ||
+        phase === "processing");
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -233,6 +250,8 @@ export async function waitForLeadListReady(input) {
             if (typeof configTarget === "number" && !targetLeadCount) {
                 targetLeadCount = configTarget;
             }
+            const signalDiscoveryHasProgressEvidence = provider === "signal-discovery" &&
+                hasSignalDiscoveryProgressEvidence(rowCount, importProgress);
             let jobId = input.jobId;
             if (!jobId && typeof config?.importJobId === "string") {
                 jobId = config.importJobId;
@@ -253,7 +272,9 @@ export async function waitForLeadListReady(input) {
                         targetLeadCount,
                     };
                 }
-                if (configError && configStatus !== "complete") {
+                if (configError &&
+                    configStatus !== "complete" &&
+                    !signalDiscoveryHasProgressEvidence) {
                     return {
                         ready: false,
                         reason: "import_failed",
@@ -267,21 +288,31 @@ export async function waitForLeadListReady(input) {
                         error: configError,
                     };
                 }
+                if (configError &&
+                    configStatus !== "complete" &&
+                    signalDiscoveryHasProgressEvidence) {
+                    lastError = configError;
+                }
                 if (configStatus) {
                     lastStatus = configStatus;
                     if (configStatus === "error") {
-                        return {
-                            ready: false,
-                            reason: "import_failed",
-                            leadListId,
-                            provider: provider ?? null,
-                            attempts,
-                            elapsedMs: Date.now() - start,
-                            rowCount,
-                            status: configStatus,
-                            targetLeadCount,
-                            error: configError,
-                        };
+                        if (signalDiscoveryHasProgressEvidence) {
+                            lastError = configError ?? lastError;
+                        }
+                        else {
+                            return {
+                                ready: false,
+                                reason: "import_failed",
+                                leadListId,
+                                provider: provider ?? null,
+                                attempts,
+                                elapsedMs: Date.now() - start,
+                                rowCount,
+                                status: configStatus,
+                                targetLeadCount,
+                                error: configError,
+                            };
+                        }
                     }
                     if (configStatus === "complete") {
                         importComplete = true;

package/dist/tools/registry.d.ts

@@ -6313,6 +6313,7 @@ export declare const allTools: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
             linkedin_url?: undefined;
@@ -6343,6 +6344,7 @@ export declare const allTools: ({
             };
             linkedinUrl?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
             linkedin_url?: undefined;
@@ -6365,6 +6367,11 @@ export declare const allTools: ({
                 description: string;
                 default: boolean;
             };
+            fetchMinimal: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
             limit?: undefined;
             postUrl?: undefined;
             sources?: undefined;
@@ -6390,6 +6397,7 @@ export declare const allTools: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             sortBy?: undefined;
             linkedin_url?: undefined;
             max_posts?: undefined;
@@ -6421,6 +6429,7 @@ export declare const allTools: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             linkedin_url?: undefined;
             max_posts?: undefined;
         };
@@ -6446,6 +6455,7 @@ export declare const allTools: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
         };
@@ -6466,6 +6476,7 @@ export declare const allTools: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
             max_posts?: undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.318",
+  "version": "0.1.319",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/building-gtm-tables/SKILL.md

@@ -111,6 +111,10 @@ Blueprint rules:
 - Use stable, readable column ids such as `linkedin_url`, `enrich_prospect`, and
   `score_icp_mcp`.
 - Use registry type keys exactly, not display names.
+- Treat the API column registry as the source of truth for type validation.
+  MCP code must not maintain its own hardcoded column-type allowlist; if the API
+  returns `phantom_type`, `deprecated_type`, or `not_createable_type`, fix the
+  blueprint to match the current registry response.
 - Treat "Enrich Prospect" as a `http_request` preset, not its own type.
 - Use `score_icp_mcp` for new AI ICP scoring. Do not use legacy
   `score_icp` or the old `score_icp_rubric` alias; they are reserved for older
@@ -145,6 +149,28 @@ Blueprint rules:
     synced sender connections, a positive `check_connection`, or accepted invite
     proof from the current flow.
 
+Config rules:
+
+- Put native column settings in `config`. The commit path preserves full config
+  objects and validates them server-side before mutation.
+- Use blueprint-level `inputMapping` for references to existing producer
+  columns. The commit path materializes those references into production
+  template mappings such as `{{<actual column id>}}` or
+  `{{<actual Enrich Prospect column id>.id}}`.
+- Use `runCondition` for branch gates that should exist in production. Template
+  tokens in `config`, AI prompts, formula expressions, and `runCondition` are
+  dependency-bearing and must point to real producer columns.
+- For outbound HTTP throttling, set `http_request.config.rateLimit` as either
+  `{ "mode": "window", "maxRequests": N, "windowSeconds": S }` or
+  `{ "mode": "concurrency", "maxConcurrent": N }`.
+- For public webhook intake throttling, set
+  `inbound_webhook.config.rateLimit` as
+  `{ "maxRequests": N, "windowSeconds": S }`. Omit it to use the server default.
+- Do not invent per-column `rateLimit` for LinkedIn action columns. Those are
+  governed by sender/account limits and scheduling windows; configure action
+  behavior with `actionConfig`, `waitForEvent`, `runCondition`, and producer
+  mappings.
+
 ## Commit phase
 
 Use exactly one tool for the initial commit:

package/skills/building-gtm-tables/references/column-type-catalog.md

@@ -55,10 +55,11 @@ read/edit/delete safety, but they are not valid `add_column` or
 
 - type: `datetime`
 - displayName: `Date/Time`
+- lifecycle: hidden active, load-only; not a valid create target.
 - category: Lead Data
 - inputs: none.
 - outputs: ISO-like date/time value.
-- when to use: Use for system-owned scheduling timestamps.
+- when to use: Existing tables may contain system-owned scheduling timestamps.
 - when NOT to use: Do not use to wait; use `wait` for sequence timing.
 
 ### Next Action
@@ -117,6 +118,8 @@ read/edit/delete safety, but they are not valid `add_column` or
 - displayName: `Inbound Webhook`
 - category: Lead Data
 - inputs: none.
+- config: optional `rateLimit` as `{ "maxRequests": N, "windowSeconds": S }`;
+  server defaults to 100 requests per 60 seconds when omitted.
 - outputs: received JSON payload and webhook metadata.
 - when to use: Use when rows are populated by external webhook events.
 - when NOT to use: Do not use for polling APIs; use `http_request`.
@@ -163,6 +166,8 @@ read/edit/delete safety, but they are not valid `add_column` or
 - displayName: `Check Open Profile`
 - category: LinkedIn Actions
 - inputs: required `linkedin_url`.
+- config: may use the same `rateLimit` shape as `http_request` for provider
+  lookup throttling.
 - outputs: boolean open-profile decision and lookup metadata.
 - when to use: Use before selecting open-profile InMail behavior.
 - when NOT to use: Do not use to check first-degree connection; use `check_connection`.
@@ -296,6 +301,11 @@ read/edit/delete safety, but they are not valid `add_column` or
 
 ## Data & Logic
 
+LinkedIn action columns do not accept a generic per-column `rateLimit`. They
+use sender/account daily limits, sending hours, and action scheduling outside
+the blueprint column config. Use `actionConfig.waitForEvent`, `runCondition`,
+and explicit producer mappings for action behavior.
+
 ### AI Column
 
 - type: `ai_column`
@@ -332,6 +342,10 @@ read/edit/delete safety, but they are not valid `add_column` or
 - displayName: `HTTP Request`
 - category: Data & Logic
 - inputs: required `method`, required `endpoint`, optional `headers`, optional `body`.
+- config: optional `rateLimit` supports rolling windows
+  `{ "mode": "window", "maxRequests": N, "windowSeconds": S }` and concurrency
+  lanes `{ "mode": "concurrency", "maxConcurrent": N }`. Omit it to use the
+  server's default I/O concurrency lane.
 - outputs: HTTP status, response body, and metadata; Enrich Prospect also returns root `id` as the EnrichedProspect id.
 - when to use: Use for REST API calls, including the canonical "Enrich Prospect" preset at `/api/v4/enrich-prospect`.
 - when NOT to use: Do not use when a first-party typed column already handles the action.