@sellable/mcp 0.1.255 → 0.1.257

package/dist/api.d.ts

@@ -10,8 +10,11 @@ export declare class SellableApiError extends Error {
     constructor(status: number, body: string, guidance?: string);
 }
 export declare class SellableApi {
+    private buildError;
+    private requestResponse;
     private request;
     get<T>(path: string): Promise<T>;
+    getText(path: string): Promise<string>;
     post<T>(path: string, body?: object): Promise<T>;
     put<T>(path: string, body?: object): Promise<T>;
     patch<T>(path: string, body?: object): Promise<T>;

package/dist/api.js

@@ -14,7 +14,21 @@ export class SellableApiError extends Error {
     }
 }
 export class SellableApi {
-    async request(method, path, body) {
+    buildError(status, errorText) {
+        const isAuthError = status === 401 || status === 403;
+        const missingWorkspace = status === 400 && errorText.includes("Workspace");
+        const guidance = isAuthError
+            ? "Sellable authentication failed.\n\n" +
+                `Update ${getConfigPath()} with a valid token from Sellable Settings -> Integrations, then retry.\n\n` +
+                "NOTE: If the token was just updated via the LLM (editing the config file), " +
+                "the change should take effect immediately. If it still fails, restart Claude Code to restart the MCP server."
+            : missingWorkspace
+                ? "No active workspace selected.\n\n" +
+                    "Run list_workspaces then set_active_workspace to choose a workspace."
+                : undefined;
+        return new SellableApiError(status, errorText, guidance);
+    }
+    async requestResponse(method, path, body) {
         // Re-read config on every request so workspace switches take effect immediately
         const config = getConfig();
         const url = `${config.apiUrl}${path}`;
@@ -30,24 +44,21 @@ export class SellableApi {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            const isAuthError = response.status === 401 || response.status === 403;
-            const missingWorkspace = response.status === 400 && errorText.includes("Workspace");
-            const guidance = isAuthError
-                ? "Sellable authentication failed.\n\n" +
-                    `Update ${getConfigPath()} with a valid token from Sellable Settings -> Integrations, then retry.\n\n` +
-                    "NOTE: If the token was just updated via the LLM (editing the config file), " +
-                    "the change should take effect immediately. If it still fails, restart Claude Code to restart the MCP server."
-                : missingWorkspace
-                    ? "No active workspace selected.\n\n" +
-                        "Run list_workspaces then set_active_workspace to choose a workspace."
-                    : undefined;
-            throw new SellableApiError(response.status, errorText, guidance);
+            throw this.buildError(response.status, errorText);
         }
+        return response;
+    }
+    async request(method, path, body) {
+        const response = await this.requestResponse(method, path, body);
         return response.json();
     }
     async get(path) {
         return this.request("GET", path);
     }
+    async getText(path) {
+        const response = await this.requestResponse("GET", path);
+        return response.text();
+    }
     async post(path, body) {
         return this.request("POST", path, body);
     }

package/dist/server.js

@@ -5,12 +5,12 @@ import { getSkillByName, listSkills } from "./skills.js";
 import { getAuthStatus } from "./tools/auth.js";
 import { handleAddColumn, handleCommitBlueprint, } from "./tools/blueprint-commit.js";
 import { bootstrapCreateCampaign } from "./tools/bootstrap.js";
-import { createCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { getCampaignTableSchema, queueCampaignCells, reviseMessageTemplateAndRerun, selectCampaignCells, waitForCampaignProcessing, } from "./tools/campaign-processing.js";
+import { createCampaign, duplicateCampaign, getCampaign, getCampaignMessagesPreview, getCampaigns, pauseCampaign, startCampaign, updateCampaign, updateCampaignBrief, } from "./tools/campaigns.js";
 import { queueCells, updateCell } from "./tools/cells.js";
 import { handleStartCliLogin, handleWaitForCliLogin, } from "./tools/cli-login.js";
+import { capturePostIdeaTool, getPostDraftTool, getPostIdeaTool, getPublishedPostTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
 import { getCampaignContext, hydrateCampaignContextFromCampaign, markCampaignContextDirty, } from "./tools/context.js";
-import { capturePostIdeaTool, getPublishedPostTool, getPostDraftTool, getPostIdeaTool, listPostDraftIterationsTool, listPostDraftsTool, listPostIdeasTool, listPublishedPostsTool, markPostPublishedTool, saveHookResearchTool, savePostDraftTool, updatePostDraftTool, updatePublishedPostMetricsTool, } from "./tools/content-posts.js";
 import { addToCommentCampaign, addToConnectionCampaign, addToInmailCampaign, getEngagedPosts, getOrCreateDirectCampaignTable, pauseDirectCampaign, startDirectCampaign, } from "./tools/direct-campaigns.js";
 import { bootstrapEngage, bootstrapEngageMulti, } from "./tools/engage-bootstrap.js";
 import { searchEngagementPosts } from "./tools/engage-discovery.js";
@@ -18,7 +18,7 @@ import { copySenderConfigTool, getEngageMemoryTool, migrateFlatConfigsTool, reco
 import { getEngageStateTool, setEngageStateTool, } from "./tools/engage-state.js";
 import { bulkEnrichWithProspeo, enrichWithProspeo, getProspeoCredits, } from "./tools/enrichment.js";
 import { getCampaignFramework } from "./tools/framework.js";
-import { cancelLeadImport, confirmProspeoCompanyAccounts, confirmLeadList, getProviderPrompt, importLeads, listDncEntriesTool, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeoCompanies, searchProspeo, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
+import { cancelLeadImport, confirmLeadList, confirmProspeoCompanyAccounts, getProviderPrompt, importLeads, loadCsvDncEntriesTool, loadCsvDomains, loadCsvLinkedinLeads, lookupSalesNavFilter, saveDomainFilters, searchApollo, searchProspeo, searchProspeoCompanies, searchSalesNav, searchSignals, selectPromisingPosts, setHeadlineICPCriteria, } from "./tools/leads.js";
 import { fetchCompany, fetchCompanyPosts, fetchLinkedInPosts, fetchLinkedInProfile, fetchPostEngagers, getLinkedInProfile, getUserPosts, } from "./tools/linkedin.js";
 import { getCampaignNavigationState } from "./tools/navigation.js";
 import { addOnDemandLeads, createOnDemandCampaign, createOnDemandTable, initOnDemandSequence, pauseOnDemandCampaign, startOnDemandCampaign, } from "./tools/one-off.js";
@@ -30,7 +30,7 @@ import { getRows, getTableRows, getTableRowsMinimal } from "./tools/rows.js";
 import { addRubricItem, checkRubric, deleteRubricItem, draftRubrics, saveRubrics, selectNecessaryRubrics, updateRubricItem, waitForRubricResults, } from "./tools/rubrics.js";
 import { getSender, listSenders } from "./tools/senders.js";
 import { attachRecommendedSequence, attachSequence, createWorkflowTable, } from "./tools/sequencer.js";
-import { listTables } from "./tools/tables.js";
+import { exportTableCsv, listTables } from "./tools/tables.js";
 import { handleVerifyTableRow } from "./tools/verify-row.js";
 import { sanitizeWatchUrlsForMcpResult } from "./tools/watch-url-security.js";
 import { addTeammate, createWorkspace, getActiveWorkspace, listWorkspaces, setActiveWorkspace, } from "./tools/workspaces.js";
@@ -208,6 +208,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "pause_campaign":
                 result = await pauseCampaign(args?.campaignId);
                 break;
+            case "duplicate_campaign":
+                result = await duplicateCampaign(args?.campaignId);
+                if (result?.campaignOfferId) {
+                    markCampaignContextDirty(result.campaignOfferId, "duplicate_campaign");
+                }
+                break;
             case "update_campaign_brief":
                 result = await updateCampaignBrief(args?.campaignId, args?.campaignBrief);
                 if (args?.campaignId) {
@@ -277,6 +283,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "list_tables":
                 result = await listTables(args);
                 break;
+            case "export_table_csv":
+                result = await exportTableCsv(args);
+                break;
             case "commit_blueprint":
                 result = await handleCommitBlueprint(args);
                 break;
@@ -366,9 +375,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "load_csv_dnc_entries":
                 result = await loadCsvDncEntriesTool(args);
                 break;
-            case "list_dnc_entries":
-                result = await listDncEntriesTool(args);
-                break;
             case "save_domain_filters":
                 result = await saveDomainFilters(args);
                 break;

package/dist/tools/campaigns.d.ts

@@ -150,6 +150,42 @@ export interface UpdateCampaignInput {
     rubric?: unknown[];
 }
 export declare const campaignToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            campaignId: {
+                type: string;
+                description: string;
+            };
+            limit?: undefined;
+            tableId?: undefined;
+            leadLimit?: undefined;
+            page?: undefined;
+            filters?: undefined;
+            name?: undefined;
+            clientProspectId?: undefined;
+            senderLinkedinUrl?: undefined;
+            offerPositioning?: undefined;
+            campaignBrief?: undefined;
+            messageGenerationMode?: undefined;
+            currentStep?: undefined;
+            watchNarration?: undefined;
+            leadSourceType?: undefined;
+            leadSourceProvider?: undefined;
+            selectedLeadListId?: undefined;
+            senderIds?: undefined;
+            interactionMode?: undefined;
+            enableICPFilters?: undefined;
+            useMessagingTemplate?: undefined;
+            rubric?: undefined;
+            flowVersion?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
     name: string;
     description: string;
     inputSchema: {
@@ -600,6 +636,11 @@ export declare function startCampaign(campaignId: string): Promise<{
 export declare function pauseCampaign(campaignId: string): Promise<{
     success: boolean;
 }>;
+export declare function duplicateCampaign(campaignId: string): Promise<{
+    campaignOfferId: string;
+    campaignName: string;
+    workflowTableId: string | null;
+}>;
 export declare function updateCampaignBrief(campaignId: string, campaignBrief: string): Promise<{
     success: boolean;
     campaignBrief: string;

package/dist/tools/campaigns.js

@@ -49,8 +49,7 @@ function getCampaignBuilderWatchModeFromUrl(watchUrl) {
 export function getCampaignBuilderWatchModeDriverLabel(mode = getCampaignBuilderWatchModeParam()) {
     return mode === "codex" ? "Codex" : "Claude Code";
 }
-export function buildCampaignWatchHandoffMarkdown(watchUrl, mode = getCampaignBuilderWatchModeFromUrl(watchUrl) ??
-    getCampaignBuilderWatchModeParam()) {
+export function buildCampaignWatchHandoffMarkdown(watchUrl, mode = getCampaignBuilderWatchModeFromUrl(watchUrl) ?? getCampaignBuilderWatchModeParam()) {
     const driverLabel = getCampaignBuilderWatchModeDriverLabel(mode);
     const headline = `WATCH ${driverLabel.toUpperCase()} BUILD THE CAMPAIGN LIVE`;
     return [
@@ -85,6 +84,21 @@ function assertBriefHandoffWatchUrl(watchUrl, campaignId) {
         "with create_campaign({ campaignId }) or get_campaign before asking for approval.");
 }
 export const campaignToolDefinitions = [
+    {
+        name: "duplicate_campaign",
+        description: "Duplicate a campaign by calling Sellable's existing duplicate endpoint. Returns campaignOfferId, campaignName, and workflowTableId for the new copy.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                campaignId: {
+                    type: "string",
+                    description: "Source campaign ID to duplicate.",
+                },
+            },
+            required: ["campaignId"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "get_campaigns",
         description: "List campaigns for the authenticated user. Returns id, name, createdAt. Ordered by most recent first.",
@@ -845,7 +859,8 @@ export async function createCampaign(input) {
         name,
         clientProspectId,
         offerPositioning,
-        ...(shouldPersistSourceStateOnCreate && input.leadSourceProvider !== undefined
+        ...(shouldPersistSourceStateOnCreate &&
+            input.leadSourceProvider !== undefined
             ? { leadSourceProvider: normalizedLeadSourceProvider }
             : {}),
         currentStep: effectiveCurrentStep,
@@ -950,6 +965,10 @@ export async function pauseCampaign(campaignId) {
     const api = getApi();
     return api.post(`/api/v3/campaigns/${campaignId}/pause`);
 }
+export async function duplicateCampaign(campaignId) {
+    const api = getApi();
+    return api.post(`/api/v3/campaigns/${campaignId}/duplicate`);
+}
 export async function updateCampaignBrief(campaignId, campaignBrief) {
     const api = getApi();
     return api.patch(`/api/v3/mcp/campaigns/${campaignId}`, { campaignBrief });

package/dist/tools/csv-dnc.d.ts

@@ -1,4 +1,3 @@
-type DncSourceType = "all" | "manual" | "hubspot";
 type InvalidDncRow = {
     row: number;
     column: string | null;
@@ -15,41 +14,6 @@ export type LoadCsvDncEntriesInput = {
     confirmationToken?: string;
     confirmed?: boolean;
 };
-export type ListDncEntriesInput = {
-    page?: number;
-    limit?: number;
-    search?: string;
-    listName?: string;
-    sourceType?: DncSourceType;
-    includeDeleted?: boolean;
-};
-export declare function listDncEntries(input?: ListDncEntriesInput): Promise<{
-    ok: boolean;
-    workspaceId: string;
-    workspaceName: string;
-    pagination: {
-        total: number;
-        page: number;
-        limit: number;
-        totalPages: number;
-    };
-    listNames: string[];
-    entries: {
-        id: string | null;
-        type: string;
-        domain: string | null;
-        linkedin: string | null;
-        linkedinUsername: string | null;
-        name: string | null;
-        source: {
-            type: string;
-            label: string;
-            listName: string | null;
-        };
-        createdAt: string | null;
-    }[];
-    guidance: string;
-}>;
 export declare function loadCsvDncEntries(input: LoadCsvDncEntriesInput): Promise<{
     guidance: string;
     createdCount: number;

package/dist/tools/csv-dnc.js

@@ -14,7 +14,6 @@ const CONFIRMATION_TOKEN_VERSION = "csv-dnc-preview-v1";
 const confirmationSecret = randomBytes(32).toString("hex");
 const MAX_DNC_UPLOAD_BYTES = 5 * 1024 * 1024;
 const MAX_DNC_CANDIDATES = 7500;
-const MAX_DNC_LIST_LIMIT = 100;
 const STRONG_DOMAIN_HEADER_KEYS = new Set([
     "domain",
     "website",
@@ -326,84 +325,16 @@ async function getVerifiedActiveWorkspace() {
     const config = getConfig();
     const activeWorkspaceId = config.activeWorkspaceId || config.workspaceId;
     if (!activeWorkspaceId) {
-        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace for the exact workspace whose Sellable DNC list should be read or updated.");
+        throw new Error("No active workspace selected. Run list_workspaces then set_active_workspace before importing DNC entries.");
     }
     const api = getApi();
     const { workspaces } = await api.get("/api/v3/workspaces");
     const match = workspaces.find((workspace) => workspace.id === activeWorkspaceId);
     if (!match) {
-        throw new Error(`Active workspace ${activeWorkspaceId} is not in the server access list. Run list_workspaces then set_active_workspace for the exact workspace whose Sellable DNC list should be read or updated.`);
+        throw new Error(`Active workspace ${activeWorkspaceId} is not in the server access list. Run list_workspaces then set_active_workspace for the workspace that should receive the DNC import.`);
     }
     return match;
 }
-function clampListPositiveInt(value, fallback, max) {
-    const parsed = typeof value === "number"
-        ? value
-        : Number.parseInt(String(value ?? ""), 10);
-    if (!Number.isFinite(parsed) || parsed < 1)
-        return fallback;
-    return Math.min(Math.floor(parsed), max);
-}
-function normalizeDncSourceType(value) {
-    if (value === undefined || value === null || value === "")
-        return "all";
-    if (value === "all" || value === "manual" || value === "hubspot") {
-        return value;
-    }
-    throw new Error("sourceType must be one of all, manual, or hubspot.");
-}
-function optionalTrimmed(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function normalizeCreatedAt(value) {
-    if (value instanceof Date)
-        return value.toISOString();
-    return optionalTrimmed(value);
-}
-function compactDncListEntry(entry) {
-    const domain = optionalTrimmed(entry.domain);
-    const linkedin = optionalTrimmed(entry.normalizedLinkedinUrl);
-    const sourceType = optionalTrimmed(entry.sourceType) ?? "manual";
-    return {
-        id: optionalTrimmed(entry.id),
-        type: domain ? "domain" : "linkedin",
-        domain,
-        linkedin,
-        linkedinUsername: optionalTrimmed(entry.linkedinUsername),
-        name: optionalTrimmed(entry.name),
-        source: {
-            type: sourceType,
-            label: optionalTrimmed(entry.sourceLabel) ??
-                (sourceType === "hubspot" ? "HubSpot" : "Manual"),
-            listName: optionalTrimmed(entry.sourceListName),
-        },
-        createdAt: normalizeCreatedAt(entry.createdAt),
-    };
-}
-function buildDncListPath(input) {
-    const page = clampListPositiveInt(input.page, 1, Number.MAX_SAFE_INTEGER);
-    const limit = clampListPositiveInt(input.limit, 25, MAX_DNC_LIST_LIMIT);
-    const sourceType = normalizeDncSourceType(input.sourceType);
-    const params = new URLSearchParams({
-        page: String(page),
-        limit: String(limit),
-    });
-    const search = optionalTrimmed(input.search);
-    const listName = optionalTrimmed(input.listName);
-    if (search)
-        params.set("search", search);
-    if (listName)
-        params.set("listName", listName);
-    if (sourceType !== "all")
-        params.set("sourceType", sourceType);
-    if (input.includeDeleted === true)
-        params.set("includeDeleted", "true");
-    return {
-        path: `/api/v3/dnc-list?${params.toString()}`,
-        page,
-        limit,
-    };
-}
 function makeSignature(payload) {
     return createHmac("sha256", confirmationSecret)
         .update(JSON.stringify(payload))
@@ -625,29 +556,6 @@ async function runDncSpotChecks(entries) {
     }
     return checks;
 }
-export async function listDncEntries(input = {}) {
-    const workspace = await getVerifiedActiveWorkspace();
-    const api = getApi();
-    const request = buildDncListPath(input);
-    const response = await api.get(request.path);
-    const pagination = response.pagination ?? {};
-    return {
-        ok: true,
-        workspaceId: workspace.id,
-        workspaceName: workspace.name,
-        pagination: {
-            total: pagination.total ?? 0,
-            page: pagination.page ?? request.page,
-            limit: pagination.limit ?? request.limit,
-            totalPages: pagination.totalPages ?? 0,
-        },
-        listNames: Array.isArray(response.listNames) ? response.listNames : [],
-        entries: Array.isArray(response.entries)
-            ? response.entries.map(compactDncListEntry)
-            : [],
-        guidance: "This is Sellable's workspace DNC list used by DNC Check.",
-    };
-}
 export async function loadCsvDncEntries(input) {
     const workspace = await getVerifiedActiveWorkspace();
     const api = getApi();

package/dist/tools/engage-discovery.d.ts

@@ -7,6 +7,7 @@ export type EngagementPost = {
         name: string;
         headline: string;
         profileUrl: string;
+        followerCount: number | null;
     };
     engagement: {
         likes: number;
@@ -14,6 +15,16 @@ export type EngagementPost = {
         shares: number;
         total: number;
     };
+    reachSignals: {
+        targetFollowerMin: number | null;
+        targetFollowerMax: number | null;
+        followerBandFit: "in_target_band" | "below_target_band" | "above_target_band" | "unknown";
+        weightedEngagement: number;
+        engagementPer1kFollowers: number | null;
+        weightedEngagementPer1kFollowers: number | null;
+        reachPenaltyMultiplier: number;
+        reachAdjustedScore: number | null;
+    };
     contentPreview: string;
 };
 export type SearchEngagementPostsInput = {
@@ -22,6 +33,8 @@ export type SearchEngagementPostsInput = {
     maxAgeDays?: number;
     minTotalEngagement?: number;
     maxPosts?: number;
+    targetFollowerMin?: number;
+    targetFollowerMax?: number;
     excludePostUrls?: string[];
 };
 export type SearchEngagementPostsResponse = {
@@ -63,6 +76,14 @@ export declare const engageDiscoveryToolDefinitions: {
                 type: string;
                 description: string;
             };
+            targetFollowerMin: {
+                type: string;
+                description: string;
+            };
+            targetFollowerMax: {
+                type: string;
+                description: string;
+            };
             excludePostUrls: {
                 type: string;
                 items: {

package/dist/tools/engage-discovery.js

@@ -27,6 +27,14 @@ export const engageDiscoveryToolDefinitions = [
                     type: "number",
                     description: "Max posts to return after filtering (default 25).",
                 },
+                targetFollowerMin: {
+                    type: "number",
+                    description: "Optional lower bound for the author's follower count when comparing reach-normalized hook performance. Does not hard-filter; adds reach signals and prioritizes the target band when follower data is available.",
+                },
+                targetFollowerMax: {
+                    type: "number",
+                    description: "Optional upper bound for the author's follower count when comparing reach-normalized hook performance. Does not hard-filter; adds reach signals and prioritizes the target band when follower data is available.",
+                },
                 excludePostUrls: {
                     type: "array",
                     items: { type: "string" },
@@ -63,6 +71,101 @@ function safeNumber(value) {
     const n = typeof value === "number" ? value : Number(value);
     return Number.isFinite(n) ? n : 0;
 }
+function parseFollowerCount(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return Math.round(value);
+    }
+    if (typeof value !== "string")
+        return null;
+    const cleaned = value.trim().toLowerCase().replace(/,/g, "");
+    if (!cleaned)
+        return null;
+    const match = cleaned.match(/(\d+(?:\.\d+)?)\s*([kmb])?/);
+    if (!match)
+        return null;
+    const base = Number(match[1]);
+    if (!Number.isFinite(base) || base <= 0)
+        return null;
+    const suffix = match[2] || "";
+    const multiplier = suffix === "b" ? 1_000_000_000 : suffix === "m" ? 1_000_000 : suffix === "k" ? 1_000 : 1;
+    return Math.round(base * multiplier);
+}
+function extractFollowerCount(post) {
+    const candidates = [
+        post?.author?.followerCount,
+        post?.author?.followersCount,
+        post?.author?.followers,
+        post?.author?.follower_count,
+        post?.author?.linkedinFollowers,
+        post?.author?.stats?.followers,
+        post?.followerCount,
+        post?.followersCount,
+        post?.followers,
+        post?.authorFollowerCount,
+    ];
+    for (const candidate of candidates) {
+        const parsed = parseFollowerCount(candidate);
+        if (parsed !== null)
+            return parsed;
+    }
+    return null;
+}
+function normalizeFollowerBound(value) {
+    const parsed = parseFollowerCount(value);
+    return parsed && parsed > 0 ? parsed : null;
+}
+function followerBandFit(followerCount, targetFollowerMin, targetFollowerMax) {
+    if (!followerCount)
+        return "unknown";
+    if (targetFollowerMin && followerCount < targetFollowerMin) {
+        return "below_target_band";
+    }
+    if (targetFollowerMax && followerCount > targetFollowerMax) {
+        return "above_target_band";
+    }
+    if (targetFollowerMin || targetFollowerMax)
+        return "in_target_band";
+    return "unknown";
+}
+function bandMultiplier(fit, followerCount, targetFollowerMax) {
+    if (fit === "in_target_band")
+        return 1;
+    if (fit === "below_target_band")
+        return 0.75;
+    if (fit === "unknown")
+        return 0.4;
+    if (!followerCount || !targetFollowerMax)
+        return 0.45;
+    if (followerCount <= targetFollowerMax * 2)
+        return 0.65;
+    if (followerCount <= targetFollowerMax * 5)
+        return 0.35;
+    return 0.15;
+}
+function reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax) {
+    const weightedEngagement = engagement.likes + engagement.comments * 4 + engagement.shares * 12;
+    const fit = followerBandFit(followerCount, targetFollowerMin, targetFollowerMax);
+    const engagementPer1kFollowers = followerCount
+        ? Number(((engagement.total / followerCount) * 1000).toFixed(3))
+        : null;
+    const weightedEngagementPer1kFollowers = followerCount
+        ? Number(((weightedEngagement / followerCount) * 1000).toFixed(3))
+        : null;
+    const reachPenaltyMultiplier = bandMultiplier(fit, followerCount, targetFollowerMax);
+    const reachAdjustedScore = weightedEngagementPer1kFollowers === null
+        ? null
+        : Number((weightedEngagementPer1kFollowers * reachPenaltyMultiplier).toFixed(3));
+    return {
+        targetFollowerMin,
+        targetFollowerMax,
+        followerBandFit: fit,
+        weightedEngagement,
+        engagementPer1kFollowers,
+        weightedEngagementPer1kFollowers,
+        reachPenaltyMultiplier,
+        reachAdjustedScore,
+    };
+}
 export async function searchEngagementPosts(input) {
     const api = getApi();
     const keywords = (input.keywords || [])
@@ -79,6 +182,10 @@ export async function searchEngagementPosts(input) {
     const maxPosts = typeof input.maxPosts === "number" && input.maxPosts > 0
         ? Math.min(50, input.maxPosts)
         : 25;
+    const targetFollowerMin = normalizeFollowerBound(input.targetFollowerMin);
+    const targetFollowerMax = normalizeFollowerBound(input.targetFollowerMax);
+    const useTargetFollowerBand = Boolean(targetFollowerMin || targetFollowerMax);
+    const collectLimit = useTargetFollowerBand ? 50 : maxPosts;
     const exclude = new Set((input.excludePostUrls || [])
         .map((u) => normalizePostUrl(u))
         .filter(Boolean));
@@ -87,11 +194,13 @@ export async function searchEngagementPosts(input) {
         keywords: keywords.map((keyword) => ({ keyword })),
         page,
     });
-    const rawPosts = Array.isArray(response?.topPostsForLLM)
-        ? response.topPostsForLLM
-        : Array.isArray(response?.posts)
-            ? response.posts
-            : [];
+    const rawPosts = useTargetFollowerBand && Array.isArray(response?.posts)
+        ? response.posts
+        : Array.isArray(response?.topPostsForLLM)
+            ? response.topPostsForLLM
+            : Array.isArray(response?.posts)
+                ? response.posts
+                : [];
     const now = Date.now();
     const oldestMs = now - maxAgeDays * 24 * 60 * 60 * 1000;
     let tooOld = 0;
@@ -111,6 +220,7 @@ export async function searchEngagementPosts(input) {
         const comments = safeNumber(p?.engagement?.comments);
         const shares = safeNumber(p?.engagement?.shares);
         const total = likes + comments + shares;
+        const engagement = { likes, comments, shares, total };
         if (total < minTotalEngagement) {
             tooLowEngagement += 1;
             continue;
@@ -121,6 +231,7 @@ export async function searchEngagementPosts(input) {
             tooOld += 1;
             continue;
         }
+        const followerCount = extractFollowerCount(p);
         kept.push({
             postId: String(p?.id || ""),
             url,
@@ -132,15 +243,31 @@ export async function searchEngagementPosts(input) {
                 name: String(p?.author?.name || ""),
                 headline: String(p?.author?.headline || ""),
                 profileUrl: String(p?.author?.profileUrl || ""),
+                followerCount,
             },
-            engagement: { likes, comments, shares, total },
+            engagement,
+            reachSignals: reachSignals(engagement, followerCount, targetFollowerMin, targetFollowerMax),
             contentPreview: previewText(String(p?.content || ""), 220),
         });
-        if (kept.length >= maxPosts)
+        if (kept.length >= collectLimit)
             break;
     }
-    // Sort by total engagement desc for a predictable shortlist.
-    kept.sort((a, b) => b.engagement.total - a.engagement.total);
+    if (useTargetFollowerBand) {
+        kept.sort((a, b) => {
+            const scoreDelta = (b.reachSignals.reachAdjustedScore ?? -1) -
+                (a.reachSignals.reachAdjustedScore ?? -1);
+            if (scoreDelta !== 0)
+                return scoreDelta;
+            return b.engagement.total - a.engagement.total;
+        });
+    }
+    else {
+        // Sort by total engagement desc for a predictable shortlist.
+        kept.sort((a, b) => b.engagement.total - a.engagement.total);
+    }
+    if (kept.length > maxPosts) {
+        kept.length = maxPosts;
+    }
     return {
         success: true,
         posts: kept,